@nmarks/graphql-codegen-per-operation-file-preset 1.0.0 → 1.0.2

package/cjs/index.js

@@ -23,9 +23,90 @@ function extractDefinitions(document) {
     }
     return definitions;
 }
+/**
+ * Check if a document actually needs type imports from the schema.
+ * Only returns true if the document uses:
+ * - Enums
+ * - Custom scalars (not built-in)
+ * - Input types (in variables)
+ *
+ * Does NOT return true for just referencing object types.
+ */
+function needsSchemaTypesImport(document, schema) {
+    const builtInScalars = ['String', 'Int', 'Float', 'Boolean', 'ID'];
+    let needsImport = false;
+    // Collect all type names referenced in the document
+    const referencedTypeNames = new Set();
+    (0, graphql_1.visit)(document, {
+        // Check variable types for input types or custom scalars
+        VariableDefinition: (node) => {
+            const typeName = getBaseTypeName(node.type);
+            referencedTypeNames.add(typeName);
+        },
+        // Collect fragment type conditions
+        FragmentDefinition: (node) => {
+            referencedTypeNames.add(node.typeCondition.name.value);
+        },
+        // We need to traverse into nested fields, so we'll collect all types
+        // This is a simplified approach - we'll check all types that might be used
+    });
+    // Helper to recursively check if a type needs importing
+    const checkType = (type) => {
+        if (!type)
+            return false;
+        // Unwrap lists and non-null
+        while ('ofType' in type && type.ofType) {
+            type = type.ofType;
+        }
+        // Enums need to be imported
+        if ((0, graphql_1.isEnumType)(type)) {
+            return true;
+        }
+        // Custom scalars (not built-in) need to be imported
+        if ((0, graphql_1.isScalarType)(type) && !builtInScalars.includes(type.name)) {
+            return true;
+        }
+        // Input types need to be imported
+        if ((0, graphql_1.isInputObjectType)(type)) {
+            return true;
+        }
+        return false;
+    };
+    // Check variable types
+    for (const typeName of referencedTypeNames) {
+        const type = schema.getType(typeName);
+        if (checkType(type)) {
+            return true;
+        }
+    }
+    // Now we need to check all fields in the document to see if any return enums/custom scalars
+    // We'll do a more thorough traversal with TypeInfo
+    const typeInfo = new graphql_1.TypeInfo(schema);
+    (0, graphql_1.visit)(document, (0, graphql_1.visitWithTypeInfo)(typeInfo, {
+        Field: () => {
+            const fieldType = typeInfo.getType();
+            if (checkType(fieldType)) {
+                needsImport = true;
+            }
+        },
+    }));
+    return needsImport;
+}
+/**
+ * Extract the base type name from a type node
+ */
+function getBaseTypeName(type) {
+    if (type.kind === 'NamedType') {
+        return type.name.value;
+    }
+    if (type.kind === 'ListType' || type.kind === 'NonNullType') {
+        return getBaseTypeName(type.type);
+    }
+    return '';
+}
 exports.preset = {
     buildGeneratesSection: options => {
-        var _a;
+        var _a, _b;
         const schemaObject = options.schemaAst
             ? options.schemaAst
             : (0, graphql_1.buildASTSchema)(options.schema, options.config);
@@ -75,12 +156,36 @@ exports.preset = {
                     ...fragmentImport,
                     outputPath: filename, // Update to actual output path
                 }));
+                // Check if THIS specific operation uses types (not the whole source file)
+                const singleDefDocumentWithFragments = {
+                    ...singleDefDocument,
+                    definitions: [
+                        ...singleDefDocument.definitions,
+                        ...source.externalFragments.map(fragment => fragment.node),
+                    ],
+                };
+                const needsTypesImport = needsSchemaTypesImport(singleDefDocumentWithFragments, schemaObject);
+                // Generate the types import statement if needed
+                const importStatements = [];
+                if (needsTypesImport && !options.config.globalNamespace) {
+                    const schemaTypesImportStatement = (0, visitor_plugin_common_1.generateImportStatement)({
+                        baseDir,
+                        emitLegacyCommonJSImports: options.config.emitLegacyCommonJSImports,
+                        importExtension: options.config.importExtension,
+                        importSource: (0, visitor_plugin_common_1.resolveImportSource)({
+                            path: shouldAbsolute ? (0, path_1.join)(options.baseOutputDir, baseTypesPath) : baseTypesPath,
+                            namespace: importTypesNamespace,
+                        }),
+                        baseOutputDir: options.baseOutputDir,
+                        outputPath: filename,
+                        typesImport: (_b = options.config.useTypeImports) !== null && _b !== void 0 ? _b : false,
+                    });
+                    importStatements.push(schemaTypesImportStatement);
+                }
                 const plugins = [
-                    ...(options.config.globalNamespace
-                        ? []
-                        : source.importStatements.map(importStatement => ({
-                            add: { content: importStatement },
-                        }))),
+                    ...importStatements.map(importStatement => ({
+                        add: { content: importStatement },
+                    })),
                     ...options.plugins,
                 ];
                 const config = {

package/esm/index.js

@@ -1,7 +1,7 @@
 import { join } from 'path';
-import { buildASTSchema, Kind } from 'graphql';
+import { buildASTSchema, isEnumType, isInputObjectType, isScalarType, Kind, TypeInfo, visit, visitWithTypeInfo } from 'graphql';
 import addPlugin from '@graphql-codegen/add';
-import { getConfigValue, } from '@graphql-codegen/visitor-plugin-common';
+import { generateImportStatement, getConfigValue, resolveImportSource, } from '@graphql-codegen/visitor-plugin-common';
 import { resolveDocumentImports } from './resolve-document-imports.js';
 import { generateOperationFilePath } from './utils.js';
 /**
@@ -19,9 +19,90 @@ function extractDefinitions(document) {
     }
     return definitions;
 }
+/**
+ * Check if a document actually needs type imports from the schema.
+ * Only returns true if the document uses:
+ * - Enums
+ * - Custom scalars (not built-in)
+ * - Input types (in variables)
+ *
+ * Does NOT return true for just referencing object types.
+ */
+function needsSchemaTypesImport(document, schema) {
+    const builtInScalars = ['String', 'Int', 'Float', 'Boolean', 'ID'];
+    let needsImport = false;
+    // Collect all type names referenced in the document
+    const referencedTypeNames = new Set();
+    visit(document, {
+        // Check variable types for input types or custom scalars
+        VariableDefinition: (node) => {
+            const typeName = getBaseTypeName(node.type);
+            referencedTypeNames.add(typeName);
+        },
+        // Collect fragment type conditions
+        FragmentDefinition: (node) => {
+            referencedTypeNames.add(node.typeCondition.name.value);
+        },
+        // We need to traverse into nested fields, so we'll collect all types
+        // This is a simplified approach - we'll check all types that might be used
+    });
+    // Helper to recursively check if a type needs importing
+    const checkType = (type) => {
+        if (!type)
+            return false;
+        // Unwrap lists and non-null
+        while ('ofType' in type && type.ofType) {
+            type = type.ofType;
+        }
+        // Enums need to be imported
+        if (isEnumType(type)) {
+            return true;
+        }
+        // Custom scalars (not built-in) need to be imported
+        if (isScalarType(type) && !builtInScalars.includes(type.name)) {
+            return true;
+        }
+        // Input types need to be imported
+        if (isInputObjectType(type)) {
+            return true;
+        }
+        return false;
+    };
+    // Check variable types
+    for (const typeName of referencedTypeNames) {
+        const type = schema.getType(typeName);
+        if (checkType(type)) {
+            return true;
+        }
+    }
+    // Now we need to check all fields in the document to see if any return enums/custom scalars
+    // We'll do a more thorough traversal with TypeInfo
+    const typeInfo = new TypeInfo(schema);
+    visit(document, visitWithTypeInfo(typeInfo, {
+        Field: () => {
+            const fieldType = typeInfo.getType();
+            if (checkType(fieldType)) {
+                needsImport = true;
+            }
+        },
+    }));
+    return needsImport;
+}
+/**
+ * Extract the base type name from a type node
+ */
+function getBaseTypeName(type) {
+    if (type.kind === 'NamedType') {
+        return type.name.value;
+    }
+    if (type.kind === 'ListType' || type.kind === 'NonNullType') {
+        return getBaseTypeName(type.type);
+    }
+    return '';
+}
 export const preset = {
     buildGeneratesSection: options => {
-        var _a;
+        var _a, _b;
         const schemaObject = options.schemaAst
             ? options.schemaAst
             : buildASTSchema(options.schema, options.config);
@@ -71,12 +152,36 @@ export const preset = {
                     ...fragmentImport,
                     outputPath: filename, // Update to actual output path
                 }));
+                // Check if THIS specific operation uses types (not the whole source file)
+                const singleDefDocumentWithFragments = {
+                    ...singleDefDocument,
+                    definitions: [
+                        ...singleDefDocument.definitions,
+                        ...source.externalFragments.map(fragment => fragment.node),
+                    ],
+                };
+                const needsTypesImport = needsSchemaTypesImport(singleDefDocumentWithFragments, schemaObject);
+                // Generate the types import statement if needed
+                const importStatements = [];
+                if (needsTypesImport && !options.config.globalNamespace) {
+                    const schemaTypesImportStatement = generateImportStatement({
+                        baseDir,
+                        emitLegacyCommonJSImports: options.config.emitLegacyCommonJSImports,
+                        importExtension: options.config.importExtension,
+                        importSource: resolveImportSource({
+                            path: shouldAbsolute ? join(options.baseOutputDir, baseTypesPath) : baseTypesPath,
+                            namespace: importTypesNamespace,
+                        }),
+                        baseOutputDir: options.baseOutputDir,
+                        outputPath: filename,
+                        typesImport: (_b = options.config.useTypeImports) !== null && _b !== void 0 ? _b : false,
+                    });
+                    importStatements.push(schemaTypesImportStatement);
+                }
                 const plugins = [
-                    ...(options.config.globalNamespace
-                        ? []
-                        : source.importStatements.map(importStatement => ({
-                            add: { content: importStatement },
-                        }))),
+                    ...importStatements.map(importStatement => ({
+                        add: { content: importStatement },
+                    })),
                     ...options.plugins,
                 ];
                 const config = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nmarks/graphql-codegen-per-operation-file-preset",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "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"