@nmarks/graphql-codegen-per-operation-file-preset 1.0.10 → 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
  */
@@ -530,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
  */
@@ -526,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.10",
+  "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>;