@graphql-codegen/visitor-plugin-common 6.2.2 → 7.0.0-alpha-20251224115216-0c4a535bdb152e75b9296d4c259f7dad0a13158f

package/cjs/selection-set-to-object.js

@@ -266,6 +266,7 @@ class SelectionSetToObject {
                     mustAddEmptyObject = true;
                 }
                 for (const incrementalNode of incrementalNodes) {
+                    // 1. fragment masking
                     if (this._config.inlineFragmentTypes === 'mask' && 'fragmentName' in incrementalNode) {
                         const { fields: incrementalFields, dependentTypes: incrementalDependentTypes } = this.buildSelectionSet(schemaType, [incrementalNode], { unsetTypes: true, parentFieldName: parentName });
                         const incrementalSet = this.selectionSetStringFromFields(incrementalFields);
@@ -273,6 +274,7 @@ class SelectionSetToObject {
                         dependentTypes.push(...incrementalDependentTypes);
                         continue;
                     }
+                    // 2. @defer
                     const { fields: initialFields, dependentTypes: initialDependentTypes } = this.buildSelectionSet(schemaType, [incrementalNode], { parentFieldName: parentName });
                     const { fields: subsequentFields, dependentTypes: subsequentDependentTypes } = this.buildSelectionSet(schemaType, [incrementalNode], { unsetTypes: true, parentFieldName: parentName });
                     const initialSet = this.selectionSetStringFromFields(initialFields);
@@ -466,12 +468,17 @@ class SelectionSetToObject {
             const selectionSetObjects = selectionSet.transformSelectionSet(options.parentFieldName ? `${options.parentFieldName}_${fieldName}` : fieldName);
             linkFieldsInterfaces.push(...selectionSetObjects.dependentTypes);
             const isConditional = (0, utils_js_1.hasConditionalDirectives)(field) || inlineFragmentConditional;
-            const isOptional = options.unsetTypes;
             linkFields.push({
                 alias: field.alias
-                    ? this._processor.config.formatNamedField(field.alias.value, selectedFieldType, isConditional, isOptional)
+                    ? this._processor.config.formatNamedField({
+                        name: field.alias.value,
+                        isOptional: isConditional || options.unsetTypes,
+                    })
                     : undefined,
-                name: this._processor.config.formatNamedField(field.name.value, selectedFieldType, isConditional, isOptional),
+                name: this._processor.config.formatNamedField({
+                    name: field.name.value,
+                    isOptional: isConditional || options.unsetTypes,
+                }),
                 type: realSelectedFieldType.name,
                 selectionSet: this._processor.config.wrapTypeWithModifiers(selectionSetObjects.mergedTypeString.split(`\n`).join(`\n  `), selectedFieldType),
             });
@@ -524,7 +531,7 @@ class SelectionSetToObject {
         if (nonOptionalTypename || addTypename || queriedForTypename) {
             const optionalTypename = !queriedForTypename && !nonOptionalTypename;
             return {
-                name: `${this._processor.config.formatNamedField('__typename')}${optionalTypename ? '?' : ''}`,
+                name: this._processor.config.formatNamedField({ name: '__typename', isOptional: optionalTypename }),
                 type: `'${type.name}'`,
             };
         }
@@ -683,20 +690,7 @@ class SelectionSetToObject {
     buildParentFieldName(typeName, parentName) {
         // queries/mutations/fragments are guaranteed to be unique type names,
         // so we can skip affixing the field names with typeName
-        if (operationTypes.includes(typeName)) {
-            return parentName;
-        }
-        const schemaType = this._schema.getType(typeName);
-        // Check if current selection set has fragments (e.g., "... AppNotificationFragment" or "... on AppNotification")
-        const hasFragment = this._selectionSet?.selections?.some(selection => selection.kind === graphql_1.Kind.INLINE_FRAGMENT || selection.kind === graphql_1.Kind.FRAGMENT_SPREAD) ?? false;
-        // When the parent schema type is an interface:
-        // - If we're processing inline fragments, use the concrete type name
-        // - If we're processing the interface directly, use the interface name
-        // - If we're in a named fragment, always use the concrete type name
-        if ((0, graphql_1.isObjectType)(schemaType) && this._parentSchemaType && (0, graphql_1.isInterfaceType)(this._parentSchemaType) && !hasFragment) {
-            return `${parentName}_${this._parentSchemaType.name}`;
-        }
-        return `${parentName}_${typeName}`;
+        return operationTypes.includes(typeName) ? parentName : `${parentName}_${typeName}`;
     }
 }
 exports.SelectionSetToObject = SelectionSetToObject;

package/cjs/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFieldNames = exports.getFieldNodeNameValue = exports.REQUIRE_FIELDS_TYPE = exports.OMIT_TYPE = exports.DeclarationBlock = exports.getConfigValue = void 0;
+exports.getNodeComment = exports.getFieldNames = exports.getFieldNodeNameValue = exports.REQUIRE_FIELDS_TYPE = exports.OMIT_TYPE = exports.DeclarationBlock = exports.getConfigValue = void 0;
 exports.quoteIfNeeded = quoteIfNeeded;
 exports.block = block;
 exports.wrapWithSingleQuotes = wrapWithSingleQuotes;
@@ -535,3 +535,24 @@ const getFieldNames = ({ selections, fieldNames = new Set(), parentName = '', lo
     return fieldNames;
 };
 exports.getFieldNames = getFieldNames;
+const getNodeComment = (node) => {
+    let commentText = node.description?.value;
+    const deprecationDirective = node.directives.find(v => v.name.value === 'deprecated');
+    if (deprecationDirective) {
+        const deprecationReason = getDeprecationReason(deprecationDirective);
+        commentText = `${commentText ? `${commentText}\n` : ''}@deprecated ${deprecationReason}`;
+    }
+    const comment = transformComment(commentText, 1);
+    return comment;
+};
+exports.getNodeComment = getNodeComment;
+const getDeprecationReason = (directive) => {
+    if (directive.name.value === 'deprecated') {
+        let reason = 'Field no longer supported';
+        const deprecatedReason = directive.arguments[0];
+        if (deprecatedReason && deprecatedReason.value.kind === graphql_1.Kind.STRING) {
+            reason = deprecatedReason.value.value;
+        }
+        return reason;
+    }
+};

package/esm/base-documents-visitor.js

@@ -37,6 +37,8 @@ export class BaseDocumentsVisitor extends BaseVisitor {
             operationResultSuffix: getConfigValue(rawConfig.operationResultSuffix, ''),
             scalars: buildScalarsFromConfig(_schema, rawConfig, defaultScalars),
             customDirectives: getConfigValue(rawConfig.customDirectives, { apolloUnmask: false }),
+            generatesOperationTypes: getConfigValue(rawConfig.generatesOperationTypes, true),
+            importSchemaTypesFrom: getConfigValue(rawConfig.importSchemaTypesFrom, ''),
             ...(additionalConfig || {}),
         });
         this._schema = _schema;
@@ -77,6 +79,9 @@ export class BaseDocumentsVisitor extends BaseVisitor {
         });
     }
     FragmentDefinition(node) {
+        if (!this.config.generatesOperationTypes) {
+            return null;
+        }
         const fragmentRootType = this._schema.getType(node.typeCondition.name.value);
         const selectionSet = this._selectionSetToObject.createNext(fragmentRootType, node.selectionSet);
         const fragmentSuffix = this.getFragmentSuffix(node);
@@ -102,6 +107,9 @@ export class BaseDocumentsVisitor extends BaseVisitor {
         return variablesBlock;
     }
     OperationDefinition(node) {
+        if (!this.config.generatesOperationTypes) {
+            return null;
+        }
         const name = this.handleAnonymousOperation(node);
         const operationRootType = getRootType(node.operation, this._schema);
         if (!operationRootType) {

package/esm/base-resolvers-visitor.js

@@ -171,17 +171,15 @@ export class BaseResolversVisitor extends BaseVisitor {
             const isMapped = this.config.mappers[typeName];
             const isScalar = this.config.scalars[typeName];
             const hasDefaultMapper = !!this.config.defaultMapper?.type;
-            // Check for mappers first, even for root types, to allow overriding rootValueType
-            if (isMapped && this.config.mappers[typeName].type && !hasPlaceholder(this.config.mappers[typeName].type)) {
-                this.markMapperAsUsed(typeName);
-                prev[typeName] = applyWrapper(this.config.mappers[typeName].type);
-                return prev;
-            }
             if (isRootType) {
                 prev[typeName] = applyWrapper(this.config.rootValueType.type);
                 return prev;
             }
-            if (isEnumType(schemaType) && this.config.enumValues[typeName]) {
+            if (isMapped && this.config.mappers[typeName].type && !hasPlaceholder(this.config.mappers[typeName].type)) {
+                this.markMapperAsUsed(typeName);
+                prev[typeName] = applyWrapper(this.config.mappers[typeName].type);
+            }
+            else if (isEnumType(schemaType) && this.config.enumValues[typeName]) {
                 const isExternalFile = !!this.config.enumValues[typeName].sourceFile;
                 prev[typeName] = isExternalFile
                     ? this.convertName(this.config.enumValues[typeName].typeIdentifier, {

package/esm/base-types-visitor.js

@@ -4,9 +4,10 @@ import { normalizeDeclarationKind } from './declaration-kinds.js';
 import { parseEnumValues } from './enum-values.js';
 import { transformDirectiveArgumentAndInputFieldMappings } from './mappers.js';
 import { DEFAULT_SCALARS } from './scalars.js';
-import { buildScalarsFromConfig, DeclarationBlock, getConfigValue, indent, isOneOfInputObjectType, transformComment, wrapWithSingleQuotes, } from './utils.js';
+import { buildScalarsFromConfig, DeclarationBlock, getConfigValue, indent, isOneOfInputObjectType, transformComment, getNodeComment, wrapWithSingleQuotes, } from './utils.js';
 import { OperationVariablesToObject } from './variables-to-object.js';
-const onlyUnderscoresPattern = /^_+$/;
+import { buildEnumValuesBlock } from './convert-schema-enum-to-declaration-block-string.js';
+import { buildTypeImport, getEnumsImports } from './imports.js';
 export class BaseTypesVisitor extends BaseVisitor {
     _schema;
     _argumentsTransformer;
@@ -55,10 +56,20 @@ export class BaseTypesVisitor extends BaseVisitor {
         return Object.keys(this.config.scalars).reduce((res, enumName) => {
             const mappedValue = this.config.scalars[enumName];
             if (mappedValue.input.isExternal) {
-                res.push(this._buildTypeImport(mappedValue.input.import, mappedValue.input.source, mappedValue.input.default));
+                res.push(buildTypeImport({
+                    identifier: mappedValue.input.import,
+                    source: mappedValue.input.source,
+                    asDefault: mappedValue.input.default,
+                    useTypeImports: this.config.useTypeImports,
+                }));
             }
             if (mappedValue.output.isExternal) {
-                res.push(this._buildTypeImport(mappedValue.output.import, mappedValue.output.source, mappedValue.output.default));
+                res.push(buildTypeImport({
+                    identifier: mappedValue.output.import,
+                    source: mappedValue.output.source,
+                    asDefault: mappedValue.output.default,
+                    useTypeImports: this.config.useTypeImports,
+                }));
             }
             return res;
         }, []);
@@ -68,7 +79,12 @@ export class BaseTypesVisitor extends BaseVisitor {
             .map(directive => {
             const mappedValue = this.config.directiveArgumentAndInputFieldMappings[directive];
             if (mappedValue.isExternal) {
-                return this._buildTypeImport(mappedValue.import, mappedValue.source, mappedValue.default);
+                return buildTypeImport({
+                    identifier: mappedValue.import,
+                    source: mappedValue.source,
+                    asDefault: mappedValue.default,
+                    useTypeImports: this.config.useTypeImports,
+                });
             }
             return null;
         })
@@ -165,7 +181,7 @@ export class BaseTypesVisitor extends BaseVisitor {
             return '';
         const typeString = node.type;
         const { type } = this._parsedConfig.declarationKind;
-        const comment = this.getNodeComment(node);
+        const comment = getNodeComment(node);
         return comment + indent(`${node.name.value}: ${typeString}${this.getPunctuation(type)}`);
     }
     UnionTypeDefinition(node, key, parent) {
@@ -249,43 +265,11 @@ export class BaseTypesVisitor extends BaseVisitor {
         // We empty this because we handle scalars in a different way, see constructor.
         return '';
     }
-    _buildTypeImport(identifier, source, asDefault = false) {
-        const { useTypeImports } = this.config;
-        if (asDefault) {
-            if (useTypeImports) {
-                return `import type { default as ${identifier} } from '${source}';`;
-            }
-            return `import ${identifier} from '${source}';`;
-        }
-        return `import${useTypeImports ? ' type' : ''} { ${identifier} } from '${source}';`;
-    }
-    handleEnumValueMapper(typeIdentifier, importIdentifier, sourceIdentifier, sourceFile) {
-        if (importIdentifier !== sourceIdentifier) {
-            // use namespace import to dereference nested enum
-            // { enumValues: { MyEnum: './my-file#NS.NestedEnum' } }
-            return [
-                this._buildTypeImport(importIdentifier || sourceIdentifier, sourceFile),
-                `import ${typeIdentifier} = ${sourceIdentifier};`,
-            ];
-        }
-        if (sourceIdentifier !== typeIdentifier) {
-            return [this._buildTypeImport(`${sourceIdentifier} as ${typeIdentifier}`, sourceFile)];
-        }
-        return [this._buildTypeImport(importIdentifier || sourceIdentifier, sourceFile)];
-    }
     getEnumsImports() {
-        return Object.keys(this.config.enumValues)
-            .flatMap(enumName => {
-            const mappedValue = this.config.enumValues[enumName];
-            if (mappedValue.sourceFile) {
-                if (mappedValue.isDefault) {
-                    return [this._buildTypeImport(mappedValue.typeIdentifier, mappedValue.sourceFile, true)];
-                }
-                return this.handleEnumValueMapper(mappedValue.typeIdentifier, mappedValue.importIdentifier, mappedValue.sourceIdentifier, mappedValue.sourceFile);
-            }
-            return [];
-        })
-            .filter(Boolean);
+        return getEnumsImports({
+            enumValues: this.config.enumValues,
+            useTypeImports: this.config.useTypeImports,
+        });
     }
     EnumTypeDefinition(node) {
         const enumName = node.name.value;
@@ -301,7 +285,21 @@ export class BaseTypesVisitor extends BaseVisitor {
             useTypesSuffix: this.config.enumSuffix,
         }))
             .withComment(node.description.value)
-            .withBlock(this.buildEnumValuesBlock(enumName, node.values)).string;
+            .withBlock(buildEnumValuesBlock({
+            typeName: enumName,
+            values: node.values,
+            schema: this._schema,
+            naming: {
+                convert: this.config.convert,
+                typesPrefix: this.config.typesPrefix,
+                useTypesPrefix: this.config.enumPrefix,
+                typesSuffix: this.config.typesSuffix,
+                useTypesSuffix: this.config.enumSuffix,
+            },
+            ignoreEnumValuesFromSchema: this.config.ignoreEnumValuesFromSchema,
+            declarationBlockConfig: this._declarationBlockConfig,
+            enumValues: this.config.enumValues,
+        })).string;
     }
     makeValidEnumIdentifier(identifier) {
         if (/^[0-9]/.exec(identifier)) {
@@ -309,31 +307,6 @@ export class BaseTypesVisitor extends BaseVisitor {
         }
         return identifier;
     }
-    buildEnumValuesBlock(typeName, values) {
-        const schemaEnumType = this._schema
-            ? this._schema.getType(typeName)
-            : undefined;
-        return values
-            .map(enumOption => {
-            const optionName = this.makeValidEnumIdentifier(this.convertName(enumOption, {
-                useTypesPrefix: false,
-                // We can only strip out the underscores if the value contains other
-                // characters. Otherwise we'll generate syntactically invalid code.
-                transformUnderscore: !onlyUnderscoresPattern.test(enumOption.name.value),
-            }));
-            const comment = this.getNodeComment(enumOption);
-            const schemaEnumValue = schemaEnumType && !this.config.ignoreEnumValuesFromSchema
-                ? schemaEnumType.getValue(enumOption.name.value).value
-                : undefined;
-            let enumValue = typeof schemaEnumValue === 'undefined' ? enumOption.name.value : schemaEnumValue;
-            if (typeof this.config.enumValues[typeName]?.mappedValues?.[enumValue] !== 'undefined') {
-                enumValue = this.config.enumValues[typeName].mappedValues[enumValue];
-            }
-            return (comment +
-                indent(`${optionName}${this._declarationBlockConfig.enumNameValueSeparator} ${wrapWithSingleQuotes(enumValue, typeof schemaEnumValue !== 'undefined')}`));
-        })
-            .join(',\n');
-    }
     DirectiveDefinition(_node) {
         return '';
     }
@@ -420,26 +393,6 @@ export class BaseTypesVisitor extends BaseVisitor {
     SchemaExtension() {
         return null;
     }
-    getNodeComment(node) {
-        let commentText = node.description?.value;
-        const deprecationDirective = node.directives.find(v => v.name.value === 'deprecated');
-        if (deprecationDirective) {
-            const deprecationReason = this.getDeprecationReason(deprecationDirective);
-            commentText = `${commentText ? `${commentText}\n` : ''}@deprecated ${deprecationReason}`;
-        }
-        const comment = transformComment(commentText, 1);
-        return comment;
-    }
-    getDeprecationReason(directive) {
-        if (directive.name.value === 'deprecated') {
-            let reason = 'Field no longer supported';
-            const deprecatedReason = directive.arguments[0];
-            if (deprecatedReason && deprecatedReason.value.kind === Kind.STRING) {
-                reason = deprecatedReason.value.value;
-            }
-            return reason;
-        }
-    }
     wrapWithListType(str) {
         return `Array<${str}>`;
     }

package/esm/base-visitor.js

@@ -1,15 +1,10 @@
 import autoBind from 'auto-bind';
 import { convertFactory } from './naming.js';
-import { normalizeImportExtension } from '@graphql-codegen/plugin-helpers';
 export class BaseVisitor {
     _parsedConfig;
     _declarationBlockConfig = {};
     scalars;
     constructor(rawConfig, additionalConfig) {
-        const importExtension = normalizeImportExtension({
-            emitLegacyCommonJSImports: rawConfig.emitLegacyCommonJSImports,
-            importExtension: rawConfig.importExtension,
-        });
         this._parsedConfig = {
             convert: convertFactory(rawConfig),
             typesPrefix: rawConfig.typesPrefix || '',
@@ -21,8 +16,7 @@ export class BaseVisitor {
             useTypeImports: !!rawConfig.useTypeImports,
             allowEnumStringTypes: !!rawConfig.allowEnumStringTypes,
             inlineFragmentTypes: rawConfig.inlineFragmentTypes ?? 'inline',
-            emitLegacyCommonJSImports: rawConfig.emitLegacyCommonJSImports ?? true,
-            importExtension,
+            emitLegacyCommonJSImports: rawConfig.emitLegacyCommonJSImports === undefined ? true : !!rawConfig.emitLegacyCommonJSImports,
             extractAllFieldsToTypes: rawConfig.extractAllFieldsToTypes ?? false,
             printFieldsOnNewLines: rawConfig.printFieldsOnNewLines ?? false,
             includeExternalFragments: rawConfig.includeExternalFragments ?? false,

package/esm/client-side-base-visitor.js

@@ -1,5 +1,5 @@
 import { basename, extname } from 'path';
-import { normalizeImportExtension, oldVisit } from '@graphql-codegen/plugin-helpers';
+import { oldVisit } from '@graphql-codegen/plugin-helpers';
 import { optimizeDocumentNode } from '@graphql-tools/optimize';
 import autoBind from 'auto-bind';
 import { pascalCase } from 'change-case-all';
@@ -292,11 +292,7 @@ export class ClientSideBaseVisitor extends BaseVisitor {
     }
     clearExtension(path) {
         const extension = extname(path);
-        const importExtension = normalizeImportExtension({
-            emitLegacyCommonJSImports: this.config.emitLegacyCommonJSImports,
-            importExtension: this.config.importExtension,
-        });
-        if (extension === importExtension) {
+        if (!this.config.emitLegacyCommonJSImports && extension === '.js') {
             return path;
         }
         if (EXTENSIONS_TO_REMOVE.includes(extension)) {
@@ -330,10 +326,9 @@ export class ClientSideBaseVisitor extends BaseVisitor {
                 if (this._collectedOperations.length > 0) {
                     if (this.config.importDocumentNodeExternallyFrom === 'near-operation-file' && this._documents.length === 1) {
                         let documentPath = `./${this.clearExtension(basename(this._documents[0].location))}`;
-                        documentPath += normalizeImportExtension({
-                            emitLegacyCommonJSImports: this.config.emitLegacyCommonJSImports,
-                            importExtension: this.config.importExtension,
-                        });
+                        if (!this.config.emitLegacyCommonJSImports) {
+                            documentPath += '.js';
+                        }
                         this._imports.add(`import * as Operations from '${documentPath}';`);
                     }
                     else {
@@ -351,10 +346,6 @@ export class ClientSideBaseVisitor extends BaseVisitor {
         }
         const excludeFragments = options.excludeFragments || this.config.globalNamespace || this.config.documentMode !== DocumentMode.graphQLTag;
         if (!excludeFragments) {
-            const importExtension = normalizeImportExtension({
-                emitLegacyCommonJSImports: this.config.emitLegacyCommonJSImports,
-                importExtension: this.config.importExtension,
-            });
             const deduplicatedImports = Object.values(groupBy(this.config.fragmentImports, fi => fi.importSource.path))
                 .map((fragmentImports) => ({
                 ...fragmentImports[0],
@@ -363,7 +354,6 @@ export class ClientSideBaseVisitor extends BaseVisitor {
                     identifiers: unique(flatten(fragmentImports.map(fi => fi.importSource.identifiers)), identifier => identifier.name),
                 },
                 emitLegacyCommonJSImports: this.config.emitLegacyCommonJSImports,
-                importExtension,
             }))
                 .filter(fragmentImport => fragmentImport.outputPath !== fragmentImport.importSource.path);
             for (const fragmentImport of deduplicatedImports) {

package/esm/convert-schema-enum-to-declaration-block-string.js

@@ -0,0 +1,159 @@
+import { DeclarationBlock, indent, transformComment, getNodeComment, wrapWithSingleQuotes, } from './utils.js';
+export const convertSchemaEnumToDeclarationBlockString = ({ schema, node, enumName, enumValues, futureProofEnums, ignoreEnumValuesFromSchema, outputType, declarationBlockConfig, naming, }) => {
+    if (enumValues[enumName]?.sourceFile) {
+        return `export { ${enumValues[enumName].typeIdentifier} };\n`;
+    }
+    const getValueFromConfig = (enumValue) => {
+        if (typeof enumValues[enumName]?.mappedValues?.[enumValue] !== 'undefined') {
+            return enumValues[enumName].mappedValues[enumValue];
+        }
+        return null;
+    };
+    const withFutureAddedValue = [futureProofEnums ? [indent('| ' + wrapWithSingleQuotes('%future added value'))] : []];
+    const enumTypeName = convertName({
+        options: {
+            typesPrefix: naming.typesPrefix,
+            typesSuffix: naming.typesSuffix,
+            useTypesPrefix: naming.useTypesPrefix,
+            useTypesSuffix: naming.useTypesSuffix,
+        },
+        convert: () => naming.convert(node),
+    });
+    if (outputType === 'string-literal') {
+        return new DeclarationBlock(declarationBlockConfig)
+            .export()
+            .asKind('type')
+            .withComment(node.description?.value)
+            .withName(enumTypeName)
+            .withContent('\n' +
+            node.values
+                .map(enumOption => {
+                const name = enumOption.name.value;
+                const enumValue = getValueFromConfig(name) ?? name;
+                const comment = transformComment(enumOption.description?.value, 1);
+                return comment + indent('| ' + wrapWithSingleQuotes(enumValue));
+            })
+                .concat(...withFutureAddedValue)
+                .join('\n')).string;
+    }
+    if (outputType === 'native-numeric') {
+        return new DeclarationBlock(declarationBlockConfig)
+            .export()
+            .withComment(node.description?.value)
+            .withName(enumTypeName)
+            .asKind('enum')
+            .withBlock(node.values
+            .map((enumOption, i) => {
+            const valueFromConfig = getValueFromConfig(enumOption.name.value);
+            const enumValue = valueFromConfig ?? i;
+            const comment = transformComment(enumOption.description?.value, 1);
+            const optionName = makeValidEnumIdentifier(convertName({
+                options: {
+                    typesPrefix: naming.typesPrefix,
+                    typesSuffix: naming.typesSuffix,
+                    useTypesPrefix: false,
+                },
+                convert: () => naming.convert(enumOption, { transformUnderscore: true }),
+            }));
+            return comment + indent(optionName) + ` = ${enumValue}`;
+        })
+            .concat(...withFutureAddedValue)
+            .join(',\n')).string;
+    }
+    if (outputType === 'const') {
+        const typeName = `export type ${enumTypeName} = typeof ${enumTypeName}[keyof typeof ${enumTypeName}];`;
+        const enumAsConst = new DeclarationBlock({
+            ...declarationBlockConfig,
+            blockTransformer: block => {
+                return block + ' as const';
+            },
+        })
+            .export()
+            .asKind('const')
+            .withName(enumTypeName)
+            .withComment(node.description?.value)
+            .withBlock(node.values
+            .map(enumOption => {
+            const optionName = makeValidEnumIdentifier(convertName({
+                options: {
+                    typesPrefix: naming.typesPrefix,
+                    typesSuffix: naming.typesPrefix,
+                },
+                convert: () => naming.convert(enumOption, {
+                    transformUnderscore: true,
+                }),
+            }));
+            const comment = transformComment(enumOption.description?.value, 1);
+            const name = enumOption.name.value;
+            const enumValue = getValueFromConfig(name) ?? name;
+            return comment + indent(`${optionName}: ${wrapWithSingleQuotes(enumValue)}`);
+        })
+            .join(',\n')).string;
+        return [enumAsConst, typeName].join('\n');
+    }
+    return new DeclarationBlock(declarationBlockConfig)
+        .export()
+        .asKind(outputType === 'native-const' ? 'const enum' : 'enum')
+        .withName(enumTypeName)
+        .withComment(node.description?.value)
+        .withBlock(buildEnumValuesBlock({
+        typeName: enumName,
+        values: node.values,
+        schema,
+        naming,
+        ignoreEnumValuesFromSchema,
+        declarationBlockConfig,
+        enumValues,
+    })).string;
+};
+export const buildEnumValuesBlock = ({ typeName, values, schema, naming, ignoreEnumValuesFromSchema, declarationBlockConfig, enumValues, }) => {
+    const schemaEnumType = schema
+        ? schema.getType(typeName)
+        : undefined;
+    return values
+        .map(enumOption => {
+        const onlyUnderscoresPattern = /^_+$/;
+        const optionName = makeValidEnumIdentifier(convertName({
+            options: {
+                useTypesPrefix: false,
+                typesPrefix: naming.typesPrefix,
+                typesSuffix: naming.typesSuffix,
+            },
+            convert: () => naming.convert(enumOption, {
+                // We can only strip out the underscores if the value contains other
+                // characters. Otherwise we'll generate syntactically invalid code.
+                transformUnderscore: !onlyUnderscoresPattern.test(enumOption.name.value),
+            }),
+        }));
+        const comment = getNodeComment(enumOption);
+        const schemaEnumValue = schemaEnumType && !ignoreEnumValuesFromSchema
+            ? schemaEnumType.getValue(enumOption.name.value).value
+            : undefined;
+        let enumValue = typeof schemaEnumValue === 'undefined' ? enumOption.name.value : schemaEnumValue;
+        if (typeof enumValues[typeName]?.mappedValues?.[enumValue] !== 'undefined') {
+            enumValue = enumValues[typeName].mappedValues[enumValue];
+        }
+        return (comment +
+            indent(`${optionName}${declarationBlockConfig.enumNameValueSeparator} ${wrapWithSingleQuotes(enumValue, typeof schemaEnumValue !== 'undefined')}`));
+    })
+        .join(',\n');
+};
+const makeValidEnumIdentifier = (identifier) => {
+    if (/^[0-9]/.exec(identifier)) {
+        return wrapWithSingleQuotes(identifier, true);
+    }
+    return identifier;
+};
+const convertName = ({ convert, options, }) => {
+    const useTypesPrefix = typeof options.useTypesPrefix === 'boolean' ? options.useTypesPrefix : true;
+    const useTypesSuffix = typeof options.useTypesSuffix === 'boolean' ? options.useTypesSuffix : true;
+    let convertedName = '';
+    if (useTypesPrefix) {
+        convertedName += options.typesPrefix;
+    }
+    convertedName += convert();
+    if (useTypesSuffix) {
+        convertedName += options.typesSuffix;
+    }
+    return convertedName;
+};

package/esm/graphql-type-utils.js

@@ -0,0 +1,11 @@
+import { isIntrospectionType, isSpecifiedScalarType } from 'graphql';
+export const isNativeNamedType = (namedType) => {
+    // "Native" NamedType in this context means the following:
+    // 1. introspection types i.e. with `__` prefixes
+    // 2. base scalars e.g. Boolean, Int, etc.
+    // 3. Other natives (mostly base scalars) which was not defined in the schema i.e. no `astNode`
+    if (isSpecifiedScalarType(namedType) || isIntrospectionType(namedType) || !namedType.astNode) {
+        return true;
+    }
+    return false;
+};