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

package/cjs/base-documents-visitor.js

@@ -41,6 +41,8 @@ class BaseDocumentsVisitor extends base_visitor_js_1.BaseVisitor {
             operationResultSuffix: (0, utils_js_1.getConfigValue)(rawConfig.operationResultSuffix, ''),
             scalars: (0, utils_js_1.buildScalarsFromConfig)(_schema, rawConfig, defaultScalars),
             customDirectives: (0, utils_js_1.getConfigValue)(rawConfig.customDirectives, { apolloUnmask: false }),
+            generatesOperationTypes: (0, utils_js_1.getConfigValue)(rawConfig.generatesOperationTypes, true),
+            importSchemaTypesFrom: (0, utils_js_1.getConfigValue)(rawConfig.importSchemaTypesFrom, ''),
             ...(additionalConfig || {}),
         });
         this._schema = _schema;
@@ -81,6 +83,9 @@ class BaseDocumentsVisitor extends base_visitor_js_1.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);
@@ -106,6 +111,9 @@ class BaseDocumentsVisitor extends base_visitor_js_1.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/cjs/base-resolvers-visitor.js

@@ -175,17 +175,15 @@ class BaseResolversVisitor extends base_visitor_js_1.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 ((0, graphql_1.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 ((0, graphql_1.isEnumType)(schemaType) && this.config.enumValues[typeName]) {
                 const isExternalFile = !!this.config.enumValues[typeName].sourceFile;
                 prev[typeName] = isExternalFile
                     ? this.convertName(this.config.enumValues[typeName].typeIdentifier, {

package/cjs/base-types-visitor.js

@@ -9,7 +9,8 @@ const mappers_js_1 = require("./mappers.js");
 const scalars_js_1 = require("./scalars.js");
 const utils_js_1 = require("./utils.js");
 const variables_to_object_js_1 = require("./variables-to-object.js");
-const onlyUnderscoresPattern = /^_+$/;
+const convert_schema_enum_to_declaration_block_string_js_1 = require("./convert-schema-enum-to-declaration-block-string.js");
+const imports_js_1 = require("./imports.js");
 class BaseTypesVisitor extends base_visitor_js_1.BaseVisitor {
     _schema;
     _argumentsTransformer;
@@ -58,10 +59,20 @@ class BaseTypesVisitor extends base_visitor_js_1.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((0, imports_js_1.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((0, imports_js_1.buildTypeImport)({
+                    identifier: mappedValue.output.import,
+                    source: mappedValue.output.source,
+                    asDefault: mappedValue.output.default,
+                    useTypeImports: this.config.useTypeImports,
+                }));
             }
             return res;
         }, []);
@@ -71,7 +82,12 @@ class BaseTypesVisitor extends base_visitor_js_1.BaseVisitor {
             .map(directive => {
             const mappedValue = this.config.directiveArgumentAndInputFieldMappings[directive];
             if (mappedValue.isExternal) {
-                return this._buildTypeImport(mappedValue.import, mappedValue.source, mappedValue.default);
+                return (0, imports_js_1.buildTypeImport)({
+                    identifier: mappedValue.import,
+                    source: mappedValue.source,
+                    asDefault: mappedValue.default,
+                    useTypeImports: this.config.useTypeImports,
+                });
             }
             return null;
         })
@@ -168,7 +184,7 @@ class BaseTypesVisitor extends base_visitor_js_1.BaseVisitor {
             return '';
         const typeString = node.type;
         const { type } = this._parsedConfig.declarationKind;
-        const comment = this.getNodeComment(node);
+        const comment = (0, utils_js_1.getNodeComment)(node);
         return comment + (0, utils_js_1.indent)(`${node.name.value}: ${typeString}${this.getPunctuation(type)}`);
     }
     UnionTypeDefinition(node, key, parent) {
@@ -252,43 +268,11 @@ class BaseTypesVisitor extends base_visitor_js_1.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 (0, imports_js_1.getEnumsImports)({
+            enumValues: this.config.enumValues,
+            useTypeImports: this.config.useTypeImports,
+        });
     }
     EnumTypeDefinition(node) {
         const enumName = node.name.value;
@@ -304,7 +288,21 @@ class BaseTypesVisitor extends base_visitor_js_1.BaseVisitor {
             useTypesSuffix: this.config.enumSuffix,
         }))
             .withComment(node.description.value)
-            .withBlock(this.buildEnumValuesBlock(enumName, node.values)).string;
+            .withBlock((0, convert_schema_enum_to_declaration_block_string_js_1.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)) {
@@ -312,31 +310,6 @@ class BaseTypesVisitor extends base_visitor_js_1.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 +
-                (0, utils_js_1.indent)(`${optionName}${this._declarationBlockConfig.enumNameValueSeparator} ${(0, utils_js_1.wrapWithSingleQuotes)(enumValue, typeof schemaEnumValue !== 'undefined')}`));
-        })
-            .join(',\n');
-    }
     DirectiveDefinition(_node) {
         return '';
     }
@@ -423,26 +396,6 @@ class BaseTypesVisitor extends base_visitor_js_1.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 = (0, utils_js_1.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 === graphql_1.Kind.STRING) {
-                reason = deprecatedReason.value.value;
-            }
-            return reason;
-        }
-    }
     wrapWithListType(str) {
         return `Array<${str}>`;
     }

package/cjs/base-visitor.js

@@ -4,16 +4,11 @@ exports.BaseVisitor = void 0;
 const tslib_1 = require("tslib");
 const auto_bind_1 = tslib_1.__importDefault(require("auto-bind"));
 const naming_js_1 = require("./naming.js");
-const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
 class BaseVisitor {
     _parsedConfig;
     _declarationBlockConfig = {};
     scalars;
     constructor(rawConfig, additionalConfig) {
-        const importExtension = (0, plugin_helpers_1.normalizeImportExtension)({
-            emitLegacyCommonJSImports: rawConfig.emitLegacyCommonJSImports,
-            importExtension: rawConfig.importExtension,
-        });
         this._parsedConfig = {
             convert: (0, naming_js_1.convertFactory)(rawConfig),
             typesPrefix: rawConfig.typesPrefix || '',
@@ -25,8 +20,7 @@ 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/cjs/client-side-base-visitor.js

@@ -296,11 +296,7 @@ class ClientSideBaseVisitor extends base_visitor_js_1.BaseVisitor {
     }
     clearExtension(path) {
         const extension = (0, path_1.extname)(path);
-        const importExtension = (0, plugin_helpers_1.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)) {
@@ -334,10 +330,9 @@ class ClientSideBaseVisitor extends base_visitor_js_1.BaseVisitor {
                 if (this._collectedOperations.length > 0) {
                     if (this.config.importDocumentNodeExternallyFrom === 'near-operation-file' && this._documents.length === 1) {
                         let documentPath = `./${this.clearExtension((0, path_1.basename)(this._documents[0].location))}`;
-                        documentPath += (0, plugin_helpers_1.normalizeImportExtension)({
-                            emitLegacyCommonJSImports: this.config.emitLegacyCommonJSImports,
-                            importExtension: this.config.importExtension,
-                        });
+                        if (!this.config.emitLegacyCommonJSImports) {
+                            documentPath += '.js';
+                        }
                         this._imports.add(`import * as Operations from '${documentPath}';`);
                     }
                     else {
@@ -355,10 +350,6 @@ class ClientSideBaseVisitor extends base_visitor_js_1.BaseVisitor {
         }
         const excludeFragments = options.excludeFragments || this.config.globalNamespace || this.config.documentMode !== DocumentMode.graphQLTag;
         if (!excludeFragments) {
-            const importExtension = (0, plugin_helpers_1.normalizeImportExtension)({
-                emitLegacyCommonJSImports: this.config.emitLegacyCommonJSImports,
-                importExtension: this.config.importExtension,
-            });
             const deduplicatedImports = Object.values((0, utils_js_1.groupBy)(this.config.fragmentImports, fi => fi.importSource.path))
                 .map((fragmentImports) => ({
                 ...fragmentImports[0],
@@ -367,7 +358,6 @@ class ClientSideBaseVisitor extends base_visitor_js_1.BaseVisitor {
                     identifiers: (0, utils_js_1.unique)((0, utils_js_1.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/cjs/convert-schema-enum-to-declaration-block-string.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEnumValuesBlock = exports.convertSchemaEnumToDeclarationBlockString = void 0;
+const utils_js_1 = require("./utils.js");
+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 ? [(0, utils_js_1.indent)('| ' + (0, utils_js_1.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 utils_js_1.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 = (0, utils_js_1.transformComment)(enumOption.description?.value, 1);
+                return comment + (0, utils_js_1.indent)('| ' + (0, utils_js_1.wrapWithSingleQuotes)(enumValue));
+            })
+                .concat(...withFutureAddedValue)
+                .join('\n')).string;
+    }
+    if (outputType === 'native-numeric') {
+        return new utils_js_1.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 = (0, utils_js_1.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 + (0, utils_js_1.indent)(optionName) + ` = ${enumValue}`;
+        })
+            .concat(...withFutureAddedValue)
+            .join(',\n')).string;
+    }
+    if (outputType === 'const') {
+        const typeName = `export type ${enumTypeName} = typeof ${enumTypeName}[keyof typeof ${enumTypeName}];`;
+        const enumAsConst = new utils_js_1.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 = (0, utils_js_1.transformComment)(enumOption.description?.value, 1);
+            const name = enumOption.name.value;
+            const enumValue = getValueFromConfig(name) ?? name;
+            return comment + (0, utils_js_1.indent)(`${optionName}: ${(0, utils_js_1.wrapWithSingleQuotes)(enumValue)}`);
+        })
+            .join(',\n')).string;
+        return [enumAsConst, typeName].join('\n');
+    }
+    return new utils_js_1.DeclarationBlock(declarationBlockConfig)
+        .export()
+        .asKind(outputType === 'native-const' ? 'const enum' : 'enum')
+        .withName(enumTypeName)
+        .withComment(node.description?.value)
+        .withBlock((0, exports.buildEnumValuesBlock)({
+        typeName: enumName,
+        values: node.values,
+        schema,
+        naming,
+        ignoreEnumValuesFromSchema,
+        declarationBlockConfig,
+        enumValues,
+    })).string;
+};
+exports.convertSchemaEnumToDeclarationBlockString = convertSchemaEnumToDeclarationBlockString;
+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 = (0, utils_js_1.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 +
+            (0, utils_js_1.indent)(`${optionName}${declarationBlockConfig.enumNameValueSeparator} ${(0, utils_js_1.wrapWithSingleQuotes)(enumValue, typeof schemaEnumValue !== 'undefined')}`));
+    })
+        .join(',\n');
+};
+exports.buildEnumValuesBlock = buildEnumValuesBlock;
+const makeValidEnumIdentifier = (identifier) => {
+    if (/^[0-9]/.exec(identifier)) {
+        return (0, utils_js_1.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/cjs/graphql-type-utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNativeNamedType = void 0;
+const graphql_1 = require("graphql");
+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 ((0, graphql_1.isSpecifiedScalarType)(namedType) || (0, graphql_1.isIntrospectionType)(namedType) || !namedType.astNode) {
+        return true;
+    }
+    return false;
+};
+exports.isNativeNamedType = isNativeNamedType;

package/cjs/imports.js

@@ -6,10 +6,11 @@ exports.resolveRelativeImport = resolveRelativeImport;
 exports.resolveImportSource = resolveImportSource;
 exports.clearExtension = clearExtension;
 exports.fixLocalFilePath = fixLocalFilePath;
+exports.getEnumsImports = getEnumsImports;
+exports.buildTypeImport = buildTypeImport;
 const tslib_1 = require("tslib");
 const path_1 = require("path");
 const parse_filepath_1 = tslib_1.__importDefault(require("parse-filepath"));
-const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
 function generateFragmentImportStatement(statement, kind) {
     const { importSource: fragmentImportSource, ...rest } = statement;
     const { identifiers, path, namespace } = fragmentImportSource;
@@ -32,12 +33,7 @@ function generateImportStatement(statement) {
     const importNames = importSource.identifiers?.length
         ? `{ ${Array.from(new Set(importSource.identifiers)).join(', ')} }`
         : '*';
-    const importExtension = importPath.startsWith('/') || importPath.startsWith('.')
-        ? (0, plugin_helpers_1.normalizeImportExtension)({
-            emitLegacyCommonJSImports: statement.emitLegacyCommonJSImports,
-            importExtension: statement.importExtension,
-        })
-        : '';
+    const importExtension = importPath.startsWith('/') || importPath.startsWith('.') ? (statement.emitLegacyCommonJSImports ? '' : '.js') : '';
     const importAlias = importSource.namespace ? ` as ${importSource.namespace}` : '';
     const importStatement = typesImport ? 'import type' : 'import';
     return `${importStatement} ${importNames}${importAlias} from '${importPath}${importExtension}';${importAlias ? '\n' : ''}`;
@@ -71,3 +67,55 @@ function clearExtension(path) {
 function fixLocalFilePath(path) {
     return path.startsWith('..') ? path : `./${path}`;
 }
+function getEnumsImports({ enumValues, useTypeImports, }) {
+    function handleEnumValueMapper({ typeIdentifier, importIdentifier, sourceIdentifier, sourceFile, useTypeImports, }) {
+        if (importIdentifier !== sourceIdentifier) {
+            // use namespace import to dereference nested enum
+            // { enumValues: { MyEnum: './my-file#NS.NestedEnum' } }
+            return [
+                buildTypeImport({ identifier: importIdentifier || sourceIdentifier, source: sourceFile, useTypeImports }),
+                `import ${typeIdentifier} = ${sourceIdentifier};`,
+            ];
+        }
+        if (sourceIdentifier !== typeIdentifier) {
+            return [
+                buildTypeImport({ identifier: `${sourceIdentifier} as ${typeIdentifier}`, source: sourceFile, useTypeImports }),
+            ];
+        }
+        return [buildTypeImport({ identifier: importIdentifier || sourceIdentifier, source: sourceFile, useTypeImports })];
+    }
+    return Object.keys(enumValues)
+        .flatMap(enumName => {
+        const mappedValue = enumValues[enumName];
+        if (mappedValue.sourceFile) {
+            if (mappedValue.isDefault) {
+                return [
+                    buildTypeImport({
+                        identifier: mappedValue.typeIdentifier,
+                        source: mappedValue.sourceFile,
+                        asDefault: true,
+                        useTypeImports,
+                    }),
+                ];
+            }
+            return handleEnumValueMapper({
+                typeIdentifier: mappedValue.typeIdentifier,
+                importIdentifier: mappedValue.importIdentifier,
+                sourceIdentifier: mappedValue.sourceIdentifier,
+                sourceFile: mappedValue.sourceFile,
+                useTypeImports,
+            });
+        }
+        return [];
+    })
+        .filter(Boolean);
+}
+function buildTypeImport({ identifier, source, useTypeImports, asDefault = false, }) {
+    if (asDefault) {
+        if (useTypeImports) {
+            return `import type { default as ${identifier} } from '${source}';`;
+        }
+        return `import ${identifier} from '${source}';`;
+    }
+    return `import${useTypeImports ? ' type' : ''} { ${identifier} } from '${source}';`;
+}

package/cjs/index.js

@@ -20,3 +20,5 @@ tslib_1.__exportStar(require("./selection-set-to-object.js"), exports);
 tslib_1.__exportStar(require("./types.js"), exports);
 tslib_1.__exportStar(require("./utils.js"), exports);
 tslib_1.__exportStar(require("./variables-to-object.js"), exports);
+tslib_1.__exportStar(require("./convert-schema-enum-to-declaration-block-string.js"), exports);
+tslib_1.__exportStar(require("./graphql-type-utils.js"), exports);

package/cjs/selection-set-processor/pre-resolve-types.js

@@ -21,9 +21,10 @@ class PreResolveTypesProcessor extends base_js_1.BaseSelectionSetProcessor {
             const fieldObj = schemaType.getFields()[field.fieldName];
             const baseType = (0, plugin_helpers_1.getBaseType)(fieldObj.type);
             let typeToUse = baseType.name;
-            const useInnerType = field.isConditional && (0, graphql_1.isNonNullType)(fieldObj.type);
-            const innerType = useInnerType ? (0, plugin_helpers_1.removeNonNullWrapper)(fieldObj.type) : undefined;
-            const name = this.config.formatNamedField(field.fieldName, useInnerType ? innerType : fieldObj.type, field.isConditional, unsetTypes);
+            const name = this.config.formatNamedField({
+                name: field.fieldName,
+                isOptional: field.isConditional || unsetTypes,
+            });
             if (unsetTypes) {
                 return {
                     name,
@@ -54,7 +55,7 @@ class PreResolveTypesProcessor extends base_js_1.BaseSelectionSetProcessor {
         }
         return fields.map(aliasedField => {
             if (aliasedField.fieldName === '__typename') {
-                const name = this.config.formatNamedField(aliasedField.alias, null);
+                const name = this.config.formatNamedField({ name: aliasedField.alias });
                 return {
                     name,
                     type: `'${schemaType.name}'`,
@@ -71,7 +72,10 @@ class PreResolveTypesProcessor extends base_js_1.BaseSelectionSetProcessor {
                             useTypesSuffix: this.config.enumSuffix,
                         });
             }
-            const name = this.config.formatNamedField(aliasedField.alias, fieldObj.type, aliasedField.isConditional, unsetTypes);
+            const name = this.config.formatNamedField({
+                name: aliasedField.alias,
+                isOptional: aliasedField.isConditional || unsetTypes,
+            });
             if (unsetTypes) {
                 return {
                     type: 'never',