@nmarks/graphql-codegen-per-operation-file-preset 1.0.9 → 1.0.11

package/cjs/index.js

@@ -8,6 +8,7 @@ const add_1 = tslib_1.__importDefault(require("@graphql-codegen/add"));
 const visitor_plugin_common_1 = require("@graphql-codegen/visitor-plugin-common");
 const resolve_document_imports_js_1 = require("./resolve-document-imports.js");
 const utils_js_1 = require("./utils.js");
+const persisted_documents_js_1 = require("./persisted-documents.js");
 /**
  * Extract operation and fragment names from a document
  */
@@ -24,18 +25,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,6 +50,54 @@ 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.
@@ -327,25 +375,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, fragmentRegistry, 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,
@@ -436,6 +531,42 @@ exports.preset = {
                 });
             }
         }
+        /**
+         * PERSISTED DOCUMENTS GENERATION
+         *
+         * If persistedDocuments is configured, generate a JSON file mapping
+         * operation hashes to their full query bodies (with __typename added).
+         * This happens in a single pass - no second document scan required.
+         */
+        const { persistedDocuments: persistedDocumentsConfig } = options.presetConfig;
+        if (persistedDocumentsConfig === null || persistedDocumentsConfig === void 0 ? void 0 : persistedDocumentsConfig.output) {
+            // Collect all source documents for persisted document generation
+            const allDocuments = options.documents;
+            // Generate the persisted documents map
+            const persistedDocsMap = (0, persisted_documents_js_1.generatePersistedDocuments)(allDocuments);
+            // Add artifact for the persisted documents JSON file
+            artifacts.push({
+                ...options,
+                filename: (0, path_1.join)(options.baseOutputDir, persistedDocumentsConfig.output),
+                plugins: [
+                    {
+                        [`persisted-documents`]: {},
+                    },
+                ],
+                pluginMap: {
+                    [`persisted-documents`]: {
+                        plugin: () => ({
+                            content: JSON.stringify(persistedDocsMap, null, 2),
+                        }),
+                    },
+                },
+                schema: options.schema,
+                schemaAst: schemaObject,
+                config: {},
+                documents: allDocuments,
+                skipDocumentsValidation: true,
+            });
+        }
         return artifacts;
     },
 };

package/cjs/persisted-documents.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTypenameToDocument = addTypenameToDocument;
+exports.collectFragmentReferences = collectFragmentReferences;
+exports.collectAllFragmentDeps = collectAllFragmentDeps;
+exports.sortTopLevelDefinitions = sortTopLevelDefinitions;
+exports.generatePersistedDocuments = generatePersistedDocuments;
+const crypto_1 = require("crypto");
+const graphql_1 = require("graphql");
+/**
+ * Adds __typename field to all selection sets matching Apollo Client's InMemoryCache behavior.
+ *
+ * Rules:
+ * - Add __typename at the END of selection sets
+ * - Skip root selection set of operations (query/mutation/subscription)
+ * - DO add __typename to fragment root selection sets
+ */
+function addTypenameToDocument(doc) {
+    return (0, graphql_1.visit)(doc, {
+        SelectionSet(node, _key, parent) {
+            // Skip root selection set of operations (parent is OperationDefinition)
+            // But DON'T skip root selection set of fragments (they should get __typename)
+            if (parent && parent.kind === graphql_1.Kind.OPERATION_DEFINITION) {
+                return node;
+            }
+            // Check if __typename already exists
+            const hasTypename = node.selections.some(selection => selection.kind === graphql_1.Kind.FIELD && selection.name.value === '__typename');
+            if (hasTypename) {
+                return node;
+            }
+            // Add __typename at the END (matching Apollo Client behavior)
+            return {
+                ...node,
+                selections: [
+                    ...node.selections,
+                    {
+                        kind: graphql_1.Kind.FIELD,
+                        name: { kind: graphql_1.Kind.NAME, value: '__typename' },
+                    },
+                ],
+            };
+        },
+    });
+}
+/**
+ * Collects all fragment names referenced in a document via FragmentSpread nodes
+ */
+function collectFragmentReferences(doc) {
+    const refs = new Set();
+    (0, graphql_1.visit)(doc, {
+        FragmentSpread(node) {
+            refs.add(node.name.value);
+        },
+    });
+    return refs;
+}
+/**
+ * Recursively collects all fragment dependencies (including nested)
+ */
+function collectAllFragmentDeps(fragmentName, fragmentMap, collected = new Set()) {
+    if (collected.has(fragmentName))
+        return collected;
+    collected.add(fragmentName);
+    const fragment = fragmentMap.get(fragmentName);
+    if (fragment) {
+        const refs = collectFragmentReferences(fragment);
+        for (const ref of refs) {
+            collectAllFragmentDeps(ref, fragmentMap, collected);
+        }
+    }
+    return collected;
+}
+/**
+ * Sort the definitions in a document so that operations come before fragments,
+ * and so that each kind of definition is sorted by name.
+ *
+ * This is a direct implementation of the sorting logic from @apollo/persisted-query-lists
+ * to avoid an external dependency.
+ */
+function sortTopLevelDefinitions(query) {
+    const definitions = [...query.definitions];
+    definitions.sort((a, b) => {
+        var _a, _b, _c, _d;
+        // This is a reverse sort by kind, so that OperationDefinition precedes FragmentDefinition.
+        if (a.kind > b.kind) {
+            return -1;
+        }
+        if (a.kind < b.kind) {
+            return 1;
+        }
+        // Extract the name from each definition
+        const aName = a.kind === graphql_1.Kind.OPERATION_DEFINITION || a.kind === graphql_1.Kind.FRAGMENT_DEFINITION
+            ? ((_b = (_a = a.name) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : '')
+            : '';
+        const bName = b.kind === graphql_1.Kind.OPERATION_DEFINITION || b.kind === graphql_1.Kind.FRAGMENT_DEFINITION
+            ? ((_d = (_c = b.name) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : '')
+            : '';
+        // Sort by name ascending.
+        if (aName < bName) {
+            return -1;
+        }
+        if (aName > bName) {
+            return 1;
+        }
+        return 0;
+    });
+    return {
+        ...query,
+        definitions,
+    };
+}
+/**
+ * Generates persisted documents map from all documents.
+ *
+ * Returns a map of hash -> query body for all operations (not standalone fragments).
+ * Each operation includes its fragment dependencies inline.
+ */
+function generatePersistedDocuments(documents) {
+    // Build fragment registry from all documents
+    const fragmentMap = new Map();
+    for (const doc of documents) {
+        if (!doc.document)
+            continue;
+        for (const def of doc.document.definitions) {
+            if (def.kind === graphql_1.Kind.FRAGMENT_DEFINITION) {
+                fragmentMap.set(def.name.value, def);
+            }
+        }
+    }
+    const result = {};
+    for (const doc of documents) {
+        if (!doc.document)
+            continue;
+        // Find operations in this document
+        const operations = doc.document.definitions.filter((def) => def.kind === graphql_1.Kind.OPERATION_DEFINITION);
+        // Skip documents with no operations (fragment-only files)
+        if (operations.length === 0)
+            continue;
+        for (const operation of operations) {
+            // Create a document with just this operation
+            let operationDoc = {
+                kind: graphql_1.Kind.DOCUMENT,
+                definitions: [operation],
+            };
+            // Collect all required fragments (recursively)
+            const directRefs = collectFragmentReferences(operationDoc);
+            const allFragments = new Set();
+            for (const ref of directRefs) {
+                collectAllFragmentDeps(ref, fragmentMap, allFragments);
+            }
+            // Add fragment definitions to the document
+            const fragmentDefs = [];
+            for (const fragName of allFragments) {
+                const frag = fragmentMap.get(fragName);
+                if (frag)
+                    fragmentDefs.push(frag);
+            }
+            if (fragmentDefs.length > 0) {
+                operationDoc = {
+                    ...operationDoc,
+                    definitions: [...operationDoc.definitions, ...fragmentDefs],
+                };
+            }
+            // Add __typename to all selection sets (matching Apollo Client behavior)
+            const docWithTypename = addTypenameToDocument(operationDoc);
+            // Sort definitions (operation first, then fragments alphabetically)
+            const sortedDoc = sortTopLevelDefinitions(docWithTypename);
+            // Print the document
+            const body = (0, graphql_1.print)(sortedDoc);
+            // Skip empty documents
+            if (!body || body.trim() === '')
+                continue;
+            // Hash is just for the JSON key - gets re-computed by generate-persisted-query-manifest
+            const hash = (0, crypto_1.createHash)('sha256').update(body).digest('hex');
+            result[hash] = body;
+        }
+    }
+    return result;
+}

package/esm/index.js

@@ -4,6 +4,7 @@ import addPlugin from '@graphql-codegen/add';
 import { generateImportStatement, getConfigValue, resolveImportSource, } from '@graphql-codegen/visitor-plugin-common';
 import { resolveDocumentImports } from './resolve-document-imports.js';
 import { generateOperationFilePath } from './utils.js';
+import { generatePersistedDocuments } from './persisted-documents.js';
 /**
  * Extract operation and fragment names from a document
  */
@@ -20,18 +21,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,6 +46,54 @@ 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.
@@ -323,25 +371,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, fragmentRegistry, 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,
@@ -432,6 +527,42 @@ export const preset = {
                 });
             }
         }
+        /**
+         * PERSISTED DOCUMENTS GENERATION
+         *
+         * If persistedDocuments is configured, generate a JSON file mapping
+         * operation hashes to their full query bodies (with __typename added).
+         * This happens in a single pass - no second document scan required.
+         */
+        const { persistedDocuments: persistedDocumentsConfig } = options.presetConfig;
+        if (persistedDocumentsConfig === null || persistedDocumentsConfig === void 0 ? void 0 : persistedDocumentsConfig.output) {
+            // Collect all source documents for persisted document generation
+            const allDocuments = options.documents;
+            // Generate the persisted documents map
+            const persistedDocsMap = generatePersistedDocuments(allDocuments);
+            // Add artifact for the persisted documents JSON file
+            artifacts.push({
+                ...options,
+                filename: join(options.baseOutputDir, persistedDocumentsConfig.output),
+                plugins: [
+                    {
+                        [`persisted-documents`]: {},
+                    },
+                ],
+                pluginMap: {
+                    [`persisted-documents`]: {
+                        plugin: () => ({
+                            content: JSON.stringify(persistedDocsMap, null, 2),
+                        }),
+                    },
+                },
+                schema: options.schema,
+                schemaAst: schemaObject,
+                config: {},
+                documents: allDocuments,
+                skipDocumentsValidation: true,
+            });
+        }
         return artifacts;
     },
 };

package/esm/persisted-documents.js

@@ -0,0 +1,172 @@
+import { createHash } from 'crypto';
+import { Kind, print, visit, } from 'graphql';
+/**
+ * Adds __typename field to all selection sets matching Apollo Client's InMemoryCache behavior.
+ *
+ * Rules:
+ * - Add __typename at the END of selection sets
+ * - Skip root selection set of operations (query/mutation/subscription)
+ * - DO add __typename to fragment root selection sets
+ */
+export function addTypenameToDocument(doc) {
+    return visit(doc, {
+        SelectionSet(node, _key, parent) {
+            // Skip root selection set of operations (parent is OperationDefinition)
+            // But DON'T skip root selection set of fragments (they should get __typename)
+            if (parent && parent.kind === Kind.OPERATION_DEFINITION) {
+                return node;
+            }
+            // Check if __typename already exists
+            const hasTypename = node.selections.some(selection => selection.kind === Kind.FIELD && selection.name.value === '__typename');
+            if (hasTypename) {
+                return node;
+            }
+            // Add __typename at the END (matching Apollo Client behavior)
+            return {
+                ...node,
+                selections: [
+                    ...node.selections,
+                    {
+                        kind: Kind.FIELD,
+                        name: { kind: Kind.NAME, value: '__typename' },
+                    },
+                ],
+            };
+        },
+    });
+}
+/**
+ * Collects all fragment names referenced in a document via FragmentSpread nodes
+ */
+export function collectFragmentReferences(doc) {
+    const refs = new Set();
+    visit(doc, {
+        FragmentSpread(node) {
+            refs.add(node.name.value);
+        },
+    });
+    return refs;
+}
+/**
+ * Recursively collects all fragment dependencies (including nested)
+ */
+export function collectAllFragmentDeps(fragmentName, fragmentMap, collected = new Set()) {
+    if (collected.has(fragmentName))
+        return collected;
+    collected.add(fragmentName);
+    const fragment = fragmentMap.get(fragmentName);
+    if (fragment) {
+        const refs = collectFragmentReferences(fragment);
+        for (const ref of refs) {
+            collectAllFragmentDeps(ref, fragmentMap, collected);
+        }
+    }
+    return collected;
+}
+/**
+ * Sort the definitions in a document so that operations come before fragments,
+ * and so that each kind of definition is sorted by name.
+ *
+ * This is a direct implementation of the sorting logic from @apollo/persisted-query-lists
+ * to avoid an external dependency.
+ */
+export function sortTopLevelDefinitions(query) {
+    const definitions = [...query.definitions];
+    definitions.sort((a, b) => {
+        var _a, _b, _c, _d;
+        // This is a reverse sort by kind, so that OperationDefinition precedes FragmentDefinition.
+        if (a.kind > b.kind) {
+            return -1;
+        }
+        if (a.kind < b.kind) {
+            return 1;
+        }
+        // Extract the name from each definition
+        const aName = a.kind === Kind.OPERATION_DEFINITION || a.kind === Kind.FRAGMENT_DEFINITION
+            ? ((_b = (_a = a.name) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : '')
+            : '';
+        const bName = b.kind === Kind.OPERATION_DEFINITION || b.kind === Kind.FRAGMENT_DEFINITION
+            ? ((_d = (_c = b.name) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : '')
+            : '';
+        // Sort by name ascending.
+        if (aName < bName) {
+            return -1;
+        }
+        if (aName > bName) {
+            return 1;
+        }
+        return 0;
+    });
+    return {
+        ...query,
+        definitions,
+    };
+}
+/**
+ * Generates persisted documents map from all documents.
+ *
+ * Returns a map of hash -> query body for all operations (not standalone fragments).
+ * Each operation includes its fragment dependencies inline.
+ */
+export function generatePersistedDocuments(documents) {
+    // Build fragment registry from all documents
+    const fragmentMap = new Map();
+    for (const doc of documents) {
+        if (!doc.document)
+            continue;
+        for (const def of doc.document.definitions) {
+            if (def.kind === Kind.FRAGMENT_DEFINITION) {
+                fragmentMap.set(def.name.value, def);
+            }
+        }
+    }
+    const result = {};
+    for (const doc of documents) {
+        if (!doc.document)
+            continue;
+        // Find operations in this document
+        const operations = doc.document.definitions.filter((def) => def.kind === Kind.OPERATION_DEFINITION);
+        // Skip documents with no operations (fragment-only files)
+        if (operations.length === 0)
+            continue;
+        for (const operation of operations) {
+            // Create a document with just this operation
+            let operationDoc = {
+                kind: Kind.DOCUMENT,
+                definitions: [operation],
+            };
+            // Collect all required fragments (recursively)
+            const directRefs = collectFragmentReferences(operationDoc);
+            const allFragments = new Set();
+            for (const ref of directRefs) {
+                collectAllFragmentDeps(ref, fragmentMap, allFragments);
+            }
+            // Add fragment definitions to the document
+            const fragmentDefs = [];
+            for (const fragName of allFragments) {
+                const frag = fragmentMap.get(fragName);
+                if (frag)
+                    fragmentDefs.push(frag);
+            }
+            if (fragmentDefs.length > 0) {
+                operationDoc = {
+                    ...operationDoc,
+                    definitions: [...operationDoc.definitions, ...fragmentDefs],
+                };
+            }
+            // Add __typename to all selection sets (matching Apollo Client behavior)
+            const docWithTypename = addTypenameToDocument(operationDoc);
+            // Sort definitions (operation first, then fragments alphabetically)
+            const sortedDoc = sortTopLevelDefinitions(docWithTypename);
+            // Print the document
+            const body = print(sortedDoc);
+            // Skip empty documents
+            if (!body || body.trim() === '')
+                continue;
+            // Hash is just for the JSON key - gets re-computed by generate-persisted-query-manifest
+            const hash = createHash('sha256').update(body).digest('hex');
+            result[hash] = body;
+        }
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nmarks/graphql-codegen-per-operation-file-preset",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "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/index.d.cts

@@ -1,4 +1,5 @@
 import { Types } from '@graphql-codegen/plugin-helpers';
+import { PersistedDocumentsConfig } from './persisted-documents.cjs';
 export type PerOperationFileConfig = {
     /**
      * @description Required, should point to the base schema types file.
@@ -126,6 +127,34 @@ export type PerOperationFileConfig = {
      * ```
      */
     importTypesNamespace?: string;
+    /**
+     * @description Optional, enables generation of a persisted-documents.json file
+     * that maps operation hashes to their full query bodies (with __typename added).
+     * Compatible with Apollo Client's persisted queries.
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file.ts': {
+     *        preset: 'per-operation-file',
+     *        plugins: ['typescript-operations'],
+     *        presetConfig: {
+     *          baseTypesPath: 'types.ts',
+     *          persistedDocuments: {
+     *            output: 'build/persisted-documents.json'
+     *          }
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    persistedDocuments?: PersistedDocumentsConfig;
 };
 /**
  * PER-OPERATION-FILE PRESET

package/typings/index.d.ts

@@ -1,4 +1,5 @@
 import { Types } from '@graphql-codegen/plugin-helpers';
+import { PersistedDocumentsConfig } from './persisted-documents.js';
 export type PerOperationFileConfig = {
     /**
      * @description Required, should point to the base schema types file.
@@ -126,6 +127,34 @@ export type PerOperationFileConfig = {
      * ```
      */
     importTypesNamespace?: string;
+    /**
+     * @description Optional, enables generation of a persisted-documents.json file
+     * that maps operation hashes to their full query bodies (with __typename added).
+     * Compatible with Apollo Client's persisted queries.
+     *
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file.ts': {
+     *        preset: 'per-operation-file',
+     *        plugins: ['typescript-operations'],
+     *        presetConfig: {
+     *          baseTypesPath: 'types.ts',
+     *          persistedDocuments: {
+     *            output: 'build/persisted-documents.json'
+     *          }
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    persistedDocuments?: PersistedDocumentsConfig;
 };
 /**
  * PER-OPERATION-FILE PRESET

package/typings/persisted-documents.d.cts

@@ -0,0 +1,44 @@
+import { DocumentNode, FragmentDefinitionNode } from 'graphql';
+import type { Source } from '@graphql-tools/utils';
+/**
+ * Configuration for persisted documents output
+ */
+export interface PersistedDocumentsConfig {
+    /**
+     * Output path for the persisted-documents.json file
+     * (relative to the baseOutputDir or absolute)
+     */
+    output: string;
+}
+/**
+ * Adds __typename field to all selection sets matching Apollo Client's InMemoryCache behavior.
+ *
+ * Rules:
+ * - Add __typename at the END of selection sets
+ * - Skip root selection set of operations (query/mutation/subscription)
+ * - DO add __typename to fragment root selection sets
+ */
+export declare function addTypenameToDocument(doc: DocumentNode): DocumentNode;
+/**
+ * Collects all fragment names referenced in a document via FragmentSpread nodes
+ */
+export declare function collectFragmentReferences(doc: DocumentNode | FragmentDefinitionNode): Set<string>;
+/**
+ * Recursively collects all fragment dependencies (including nested)
+ */
+export declare function collectAllFragmentDeps(fragmentName: string, fragmentMap: Map<string, FragmentDefinitionNode>, collected?: Set<string>): Set<string>;
+/**
+ * Sort the definitions in a document so that operations come before fragments,
+ * and so that each kind of definition is sorted by name.
+ *
+ * This is a direct implementation of the sorting logic from @apollo/persisted-query-lists
+ * to avoid an external dependency.
+ */
+export declare function sortTopLevelDefinitions(query: DocumentNode): DocumentNode;
+/**
+ * Generates persisted documents map from all documents.
+ *
+ * Returns a map of hash -> query body for all operations (not standalone fragments).
+ * Each operation includes its fragment dependencies inline.
+ */
+export declare function generatePersistedDocuments(documents: Source[]): Record<string, string>;

package/typings/persisted-documents.d.ts

@@ -0,0 +1,44 @@
+import { DocumentNode, FragmentDefinitionNode } from 'graphql';
+import type { Source } from '@graphql-tools/utils';
+/**
+ * Configuration for persisted documents output
+ */
+export interface PersistedDocumentsConfig {
+    /**
+     * Output path for the persisted-documents.json file
+     * (relative to the baseOutputDir or absolute)
+     */
+    output: string;
+}
+/**
+ * Adds __typename field to all selection sets matching Apollo Client's InMemoryCache behavior.
+ *
+ * Rules:
+ * - Add __typename at the END of selection sets
+ * - Skip root selection set of operations (query/mutation/subscription)
+ * - DO add __typename to fragment root selection sets
+ */
+export declare function addTypenameToDocument(doc: DocumentNode): DocumentNode;
+/**
+ * Collects all fragment names referenced in a document via FragmentSpread nodes
+ */
+export declare function collectFragmentReferences(doc: DocumentNode | FragmentDefinitionNode): Set<string>;
+/**
+ * Recursively collects all fragment dependencies (including nested)
+ */
+export declare function collectAllFragmentDeps(fragmentName: string, fragmentMap: Map<string, FragmentDefinitionNode>, collected?: Set<string>): Set<string>;
+/**
+ * Sort the definitions in a document so that operations come before fragments,
+ * and so that each kind of definition is sorted by name.
+ *
+ * This is a direct implementation of the sorting logic from @apollo/persisted-query-lists
+ * to avoid an external dependency.
+ */
+export declare function sortTopLevelDefinitions(query: DocumentNode): DocumentNode;
+/**
+ * Generates persisted documents map from all documents.
+ *
+ * Returns a map of hash -> query body for all operations (not standalone fragments).
+ * Each operation includes its fragment dependencies inline.
+ */
+export declare function generatePersistedDocuments(documents: Source[]): Record<string, string>;