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

package/esm/imports.js

@@ -1,6 +1,5 @@
 import { dirname, isAbsolute, join, relative, resolve } from 'path';
 import parse from 'parse-filepath';
-import { normalizeImportExtension } from '@graphql-codegen/plugin-helpers';
 export function generateFragmentImportStatement(statement, kind) {
     const { importSource: fragmentImportSource, ...rest } = statement;
     const { identifiers, path, namespace } = fragmentImportSource;
@@ -23,12 +22,7 @@ export function generateImportStatement(statement) {
     const importNames = importSource.identifiers?.length
         ? `{ ${Array.from(new Set(importSource.identifiers)).join(', ')} }`
         : '*';
-    const importExtension = importPath.startsWith('/') || importPath.startsWith('.')
-        ? 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' : ''}`;
@@ -62,3 +56,55 @@ export function clearExtension(path) {
 export function fixLocalFilePath(path) {
     return path.startsWith('..') ? path : `./${path}`;
 }
+export 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);
+}
+export 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/esm/index.js

@@ -17,3 +17,5 @@ export * from './selection-set-to-object.js';
 export * from './types.js';
 export * from './utils.js';
 export * from './variables-to-object.js';
+export * from './convert-schema-enum-to-declaration-block-string.js';
+export * from './graphql-type-utils.js';

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

@@ -1,5 +1,5 @@
-import { getBaseType, removeNonNullWrapper } from '@graphql-codegen/plugin-helpers';
-import { isEnumType, isNonNullType } from 'graphql';
+import { getBaseType } from '@graphql-codegen/plugin-helpers';
+import { isEnumType } from 'graphql';
 import { BaseSelectionSetProcessor, } from './base.js';
 export class PreResolveTypesProcessor extends BaseSelectionSetProcessor {
     transformTypenameField(type, name) {
@@ -18,9 +18,10 @@ export class PreResolveTypesProcessor extends BaseSelectionSetProcessor {
             const fieldObj = schemaType.getFields()[field.fieldName];
             const baseType = getBaseType(fieldObj.type);
             let typeToUse = baseType.name;
-            const useInnerType = field.isConditional && isNonNullType(fieldObj.type);
-            const innerType = useInnerType ? 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,
@@ -51,7 +52,7 @@ export class PreResolveTypesProcessor extends 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}'`,
@@ -68,7 +69,10 @@ export class PreResolveTypesProcessor extends 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',

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

@@ -262,6 +262,7 @@ export 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);
@@ -269,6 +270,7 @@ export 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);
@@ -462,12 +464,17 @@ export class SelectionSetToObject {
             const selectionSetObjects = selectionSet.transformSelectionSet(options.parentFieldName ? `${options.parentFieldName}_${fieldName}` : fieldName);
             linkFieldsInterfaces.push(...selectionSetObjects.dependentTypes);
             const isConditional = 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),
             });
@@ -520,7 +527,7 @@ export 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}'`,
             };
         }
@@ -679,20 +686,7 @@ export 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 === Kind.INLINE_FRAGMENT || selection.kind === 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 (isObjectType(schemaType) && this._parentSchemaType && isInterfaceType(this._parentSchemaType) && !hasFragment) {
-            return `${parentName}_${this._parentSchemaType.name}`;
-        }
-        return `${parentName}_${typeName}`;
+        return operationTypes.includes(typeName) ? parentName : `${parentName}_${typeName}`;
     }
 }
 function formatUnion(members) {

package/esm/utils.js

@@ -503,3 +503,23 @@ export const getFieldNames = ({ selections, fieldNames = new Set(), parentName =
     }
     return fieldNames;
 };
+export 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;
+};
+const 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;
+    }
+};

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@graphql-codegen/visitor-plugin-common",
-  "version": "6.2.2",
+  "version": "7.0.0-alpha-20251224115216-0c4a535bdb152e75b9296d4c259f7dad0a13158f",
   "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"
   },
   "dependencies": {
     "@graphql-tools/optimize": "^2.0.0",
-    "@graphql-codegen/plugin-helpers": "^6.1.0",
+    "@graphql-codegen/plugin-helpers": "^6.0.0",
     "@graphql-tools/relay-operation-optimizer": "^7.0.0",
     "@graphql-tools/utils": "^10.0.0",
     "auto-bind": "~4.0.0",

package/typings/base-documents-visitor.d.cts

@@ -19,6 +19,8 @@ export interface ParsedDocumentsConfig extends ParsedTypesConfig {
     experimentalFragmentVariables: boolean;
     mergeFragmentTypes: boolean;
     customDirectives: CustomDirectivesConfig;
+    generatesOperationTypes: boolean;
+    importSchemaTypesFrom: string;
 }
 export interface RawDocumentsConfig extends RawTypesConfig {
     /**
@@ -149,6 +151,52 @@ export interface RawDocumentsConfig extends RawTypesConfig {
      * ```
      */
     customDirectives?: CustomDirectivesConfig;
+    /**
+     * @description Whether to generate operation types such as Variables, Query/Mutation/Subscription selection set, and Fragment types
+     * This can be used with `importSchemaTypesFrom` to generate shared used Enums and Input.
+     * @default true
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file.ts': {
+     *        plugins: ['typescript-operations'],
+     *        config: {
+     *          generatesOperationTypes: false,
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    generatesOperationTypes?: boolean;
+    /**
+     * @description The absolute (prefixed with `~`) or relative path from `cwd` to the shared used Enums and Input (See `generatesOperationTypes`).
+     * @default true
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file.ts': {
+     *        plugins: ['typescript-operations'],
+     *        config: {
+     *          importSchemaTypesFrom: './path/to/shared-types.ts', // relative
+     *          importSchemaTypesFrom: '~@my-org/package' // absolute
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    importSchemaTypesFrom?: string;
 }
 export declare class BaseDocumentsVisitor<TRawConfig extends RawDocumentsConfig = RawDocumentsConfig, TPluginConfig extends ParsedDocumentsConfig = ParsedDocumentsConfig> extends BaseVisitor<TRawConfig, TPluginConfig> {
     protected _schema: GraphQLSchema;
@@ -166,5 +214,5 @@ export declare class BaseDocumentsVisitor<TRawConfig extends RawDocumentsConfig
     private handleAnonymousOperation;
     FragmentDefinition(node: FragmentDefinitionNode): string;
     protected applyVariablesWrapper(variablesBlock: string, _operationType?: string): string;
-    OperationDefinition(node: OperationDefinitionNode): string;
+    OperationDefinition(node: OperationDefinitionNode): string | null;
 }

package/typings/base-documents-visitor.d.ts

@@ -19,6 +19,8 @@ export interface ParsedDocumentsConfig extends ParsedTypesConfig {
     experimentalFragmentVariables: boolean;
     mergeFragmentTypes: boolean;
     customDirectives: CustomDirectivesConfig;
+    generatesOperationTypes: boolean;
+    importSchemaTypesFrom: string;
 }
 export interface RawDocumentsConfig extends RawTypesConfig {
     /**
@@ -149,6 +151,52 @@ export interface RawDocumentsConfig extends RawTypesConfig {
      * ```
      */
     customDirectives?: CustomDirectivesConfig;
+    /**
+     * @description Whether to generate operation types such as Variables, Query/Mutation/Subscription selection set, and Fragment types
+     * This can be used with `importSchemaTypesFrom` to generate shared used Enums and Input.
+     * @default true
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file.ts': {
+     *        plugins: ['typescript-operations'],
+     *        config: {
+     *          generatesOperationTypes: false,
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    generatesOperationTypes?: boolean;
+    /**
+     * @description The absolute (prefixed with `~`) or relative path from `cwd` to the shared used Enums and Input (See `generatesOperationTypes`).
+     * @default true
+     * @exampleMarkdown
+     * ```ts filename="codegen.ts"
+     *  import type { CodegenConfig } from '@graphql-codegen/cli';
+     *
+     *  const config: CodegenConfig = {
+     *    // ...
+     *    generates: {
+     *      'path/to/file.ts': {
+     *        plugins: ['typescript-operations'],
+     *        config: {
+     *          importSchemaTypesFrom: './path/to/shared-types.ts', // relative
+     *          importSchemaTypesFrom: '~@my-org/package' // absolute
+     *        },
+     *      },
+     *    },
+     *  };
+     *  export default config;
+     * ```
+     */
+    importSchemaTypesFrom?: string;
 }
 export declare class BaseDocumentsVisitor<TRawConfig extends RawDocumentsConfig = RawDocumentsConfig, TPluginConfig extends ParsedDocumentsConfig = ParsedDocumentsConfig> extends BaseVisitor<TRawConfig, TPluginConfig> {
     protected _schema: GraphQLSchema;
@@ -166,5 +214,5 @@ export declare class BaseDocumentsVisitor<TRawConfig extends RawDocumentsConfig
     private handleAnonymousOperation;
     FragmentDefinition(node: FragmentDefinitionNode): string;
     protected applyVariablesWrapper(variablesBlock: string, _operationType?: string): string;
-    OperationDefinition(node: OperationDefinitionNode): string;
+    OperationDefinition(node: OperationDefinitionNode): string | null;
 }

package/typings/base-types-visitor.d.cts

@@ -1,4 +1,4 @@
-import { DirectiveDefinitionNode, DirectiveNode, EnumTypeDefinitionNode, EnumValueDefinitionNode, FieldDefinitionNode, GraphQLSchema, InputObjectTypeDefinitionNode, InputValueDefinitionNode, InterfaceTypeDefinitionNode, ListTypeNode, NamedTypeNode, NonNullTypeNode, ObjectTypeDefinitionNode, ScalarTypeDefinitionNode, UnionTypeDefinitionNode } from 'graphql';
+import { DirectiveDefinitionNode, DirectiveNode, EnumTypeDefinitionNode, FieldDefinitionNode, GraphQLSchema, InputObjectTypeDefinitionNode, InputValueDefinitionNode, InterfaceTypeDefinitionNode, ListTypeNode, NamedTypeNode, NonNullTypeNode, ObjectTypeDefinitionNode, ScalarTypeDefinitionNode, UnionTypeDefinitionNode } from 'graphql';
 import { BaseVisitor, ParsedConfig, RawConfig } from './base-visitor.cjs';
 import { DeclarationKind, DeclarationKindConfig, DirectiveArgumentAndInputFieldMappings, EnumValuesMap, NormalizedScalarsMap, ParsedDirectiveArgumentAndInputFieldMappings, ParsedEnumValuesMap } from './types.cjs';
 import { DeclarationBlock, DeclarationBlockConfig } from './utils.cjs';
@@ -478,12 +478,9 @@ export declare class BaseTypesVisitor<TRawConfig extends RawTypesConfig = RawTyp
     getInterfaceTypeDeclarationBlock(node: InterfaceTypeDefinitionNode, _originalNode: InterfaceTypeDefinitionNode): DeclarationBlock;
     InterfaceTypeDefinition(node: InterfaceTypeDefinitionNode, key: number | string, parent: any): string;
     ScalarTypeDefinition(_node: ScalarTypeDefinitionNode): string;
-    protected _buildTypeImport(identifier: string, source: string, asDefault?: boolean): string;
-    protected handleEnumValueMapper(typeIdentifier: string, importIdentifier: string | null, sourceIdentifier: string | null, sourceFile: string | null): string[];
     getEnumsImports(): string[];
     EnumTypeDefinition(node: EnumTypeDefinitionNode): string;
     protected makeValidEnumIdentifier(identifier: string): string;
-    protected buildEnumValuesBlock(typeName: string, values: ReadonlyArray<EnumValueDefinitionNode>): string;
     DirectiveDefinition(_node: DirectiveDefinitionNode): string;
     getArgumentsObjectDeclarationBlock(node: InterfaceTypeDefinitionNode | ObjectTypeDefinitionNode, name: string, field: FieldDefinitionNode): DeclarationBlock;
     getArgumentsObjectTypeDefinition(node: InterfaceTypeDefinitionNode | ObjectTypeDefinitionNode, name: string, field: FieldDefinitionNode): string;
@@ -496,7 +493,5 @@ export declare class BaseTypesVisitor<TRawConfig extends RawTypesConfig = RawTyp
     ListType(node: ListTypeNode, _key: any, _parent: any, _path: any, _ancestors: any): string;
     SchemaDefinition(): any;
     SchemaExtension(): any;
-    getNodeComment(node: FieldDefinitionNode | EnumValueDefinitionNode | InputValueDefinitionNode): string;
-    protected getDeprecationReason(directive: DirectiveNode): string | void;
     protected wrapWithListType(str: string): string;
 }

package/typings/base-types-visitor.d.ts

@@ -1,4 +1,4 @@
-import { DirectiveDefinitionNode, DirectiveNode, EnumTypeDefinitionNode, EnumValueDefinitionNode, FieldDefinitionNode, GraphQLSchema, InputObjectTypeDefinitionNode, InputValueDefinitionNode, InterfaceTypeDefinitionNode, ListTypeNode, NamedTypeNode, NonNullTypeNode, ObjectTypeDefinitionNode, ScalarTypeDefinitionNode, UnionTypeDefinitionNode } from 'graphql';
+import { DirectiveDefinitionNode, DirectiveNode, EnumTypeDefinitionNode, FieldDefinitionNode, GraphQLSchema, InputObjectTypeDefinitionNode, InputValueDefinitionNode, InterfaceTypeDefinitionNode, ListTypeNode, NamedTypeNode, NonNullTypeNode, ObjectTypeDefinitionNode, ScalarTypeDefinitionNode, UnionTypeDefinitionNode } from 'graphql';
 import { BaseVisitor, ParsedConfig, RawConfig } from './base-visitor.js';
 import { DeclarationKind, DeclarationKindConfig, DirectiveArgumentAndInputFieldMappings, EnumValuesMap, NormalizedScalarsMap, ParsedDirectiveArgumentAndInputFieldMappings, ParsedEnumValuesMap } from './types.js';
 import { DeclarationBlock, DeclarationBlockConfig } from './utils.js';
@@ -478,12 +478,9 @@ export declare class BaseTypesVisitor<TRawConfig extends RawTypesConfig = RawTyp
     getInterfaceTypeDeclarationBlock(node: InterfaceTypeDefinitionNode, _originalNode: InterfaceTypeDefinitionNode): DeclarationBlock;
     InterfaceTypeDefinition(node: InterfaceTypeDefinitionNode, key: number | string, parent: any): string;
     ScalarTypeDefinition(_node: ScalarTypeDefinitionNode): string;
-    protected _buildTypeImport(identifier: string, source: string, asDefault?: boolean): string;
-    protected handleEnumValueMapper(typeIdentifier: string, importIdentifier: string | null, sourceIdentifier: string | null, sourceFile: string | null): string[];
     getEnumsImports(): string[];
     EnumTypeDefinition(node: EnumTypeDefinitionNode): string;
     protected makeValidEnumIdentifier(identifier: string): string;
-    protected buildEnumValuesBlock(typeName: string, values: ReadonlyArray<EnumValueDefinitionNode>): string;
     DirectiveDefinition(_node: DirectiveDefinitionNode): string;
     getArgumentsObjectDeclarationBlock(node: InterfaceTypeDefinitionNode | ObjectTypeDefinitionNode, name: string, field: FieldDefinitionNode): DeclarationBlock;
     getArgumentsObjectTypeDefinition(node: InterfaceTypeDefinitionNode | ObjectTypeDefinitionNode, name: string, field: FieldDefinitionNode): string;
@@ -496,7 +493,5 @@ export declare class BaseTypesVisitor<TRawConfig extends RawTypesConfig = RawTyp
     ListType(node: ListTypeNode, _key: any, _parent: any, _path: any, _ancestors: any): string;
     SchemaDefinition(): any;
     SchemaExtension(): any;
-    getNodeComment(node: FieldDefinitionNode | EnumValueDefinitionNode | InputValueDefinitionNode): string;
-    protected getDeprecationReason(directive: DirectiveNode): string | void;
     protected wrapWithListType(str: string): string;
 }

package/typings/base-visitor.d.cts

@@ -21,8 +21,7 @@ export interface ParsedConfig {
     useTypeImports: boolean;
     allowEnumStringTypes: boolean;
     inlineFragmentTypes: InlineFragmentTypeOptions;
-    emitLegacyCommonJSImports?: boolean;
-    importExtension: '' | `.${string}`;
+    emitLegacyCommonJSImports: boolean;
     printFieldsOnNewLines: boolean;
     includeExternalFragments: boolean;
 }
@@ -344,17 +343,11 @@ export interface RawConfig {
      */
     inlineFragmentTypes?: InlineFragmentTypeOptions;
     /**
-     * @deprecated Please use `importExtension` instead.
      * @default true
      * @description Emit legacy common js imports.
      * Default it will be `true` this way it ensure that generated code works with [non-compliant bundlers](https://github.com/dotansimha/graphql-code-generator/issues/8065).
      */
     emitLegacyCommonJSImports?: boolean;
-    /**
-     * @description Append this extension to all imports.
-     * Useful for ESM environments that require file extensions in import statements.
-     */
-    importExtension?: '' | `.${string}`;
     /**
      * @default false
      * @description Extract all field types to their own types, instead of inlining them.

package/typings/base-visitor.d.ts

@@ -21,8 +21,7 @@ export interface ParsedConfig {
     useTypeImports: boolean;
     allowEnumStringTypes: boolean;
     inlineFragmentTypes: InlineFragmentTypeOptions;
-    emitLegacyCommonJSImports?: boolean;
-    importExtension: '' | `.${string}`;
+    emitLegacyCommonJSImports: boolean;
     printFieldsOnNewLines: boolean;
     includeExternalFragments: boolean;
 }
@@ -344,17 +343,11 @@ export interface RawConfig {
      */
     inlineFragmentTypes?: InlineFragmentTypeOptions;
     /**
-     * @deprecated Please use `importExtension` instead.
      * @default true
      * @description Emit legacy common js imports.
      * Default it will be `true` this way it ensure that generated code works with [non-compliant bundlers](https://github.com/dotansimha/graphql-code-generator/issues/8065).
      */
     emitLegacyCommonJSImports?: boolean;
-    /**
-     * @description Append this extension to all imports.
-     * Useful for ESM environments that require file extensions in import statements.
-     */
-    importExtension?: '' | `.${string}`;
     /**
      * @default false
      * @description Extract all field types to their own types, instead of inlining them.

package/typings/convert-schema-enum-to-declaration-block-string.d.cts

@@ -0,0 +1,25 @@
+import type { EnumTypeDefinitionNode, EnumValueDefinitionNode, GraphQLSchema } from 'graphql';
+import type { ConvertFn, ParsedEnumValuesMap } from './types.cjs';
+import { type DeclarationBlockConfig } from './utils.cjs';
+export interface ConvertSchemaEnumToDeclarationBlockString {
+    schema: GraphQLSchema;
+    node: EnumTypeDefinitionNode;
+    enumName: string;
+    enumValues: ParsedEnumValuesMap;
+    futureProofEnums: boolean;
+    ignoreEnumValuesFromSchema: boolean;
+    naming: {
+        convert: ConvertFn;
+        typesPrefix: string;
+        typesSuffix: string;
+        useTypesPrefix?: boolean;
+        useTypesSuffix?: boolean;
+    };
+    outputType: 'string-literal' | 'native-numeric' | 'const' | 'native-const' | 'native';
+    declarationBlockConfig: DeclarationBlockConfig;
+}
+export declare const convertSchemaEnumToDeclarationBlockString: ({ schema, node, enumName, enumValues, futureProofEnums, ignoreEnumValuesFromSchema, outputType, declarationBlockConfig, naming, }: ConvertSchemaEnumToDeclarationBlockString) => string;
+export declare const buildEnumValuesBlock: ({ typeName, values, schema, naming, ignoreEnumValuesFromSchema, declarationBlockConfig, enumValues, }: Pick<ConvertSchemaEnumToDeclarationBlockString, "schema" | "naming" | "ignoreEnumValuesFromSchema" | "declarationBlockConfig" | "enumValues"> & {
+    typeName: string;
+    values: ReadonlyArray<EnumValueDefinitionNode>;
+}) => string;

package/typings/convert-schema-enum-to-declaration-block-string.d.ts

@@ -0,0 +1,25 @@
+import type { EnumTypeDefinitionNode, EnumValueDefinitionNode, GraphQLSchema } from 'graphql';
+import type { ConvertFn, ParsedEnumValuesMap } from './types.js';
+import { type DeclarationBlockConfig } from './utils.js';
+export interface ConvertSchemaEnumToDeclarationBlockString {
+    schema: GraphQLSchema;
+    node: EnumTypeDefinitionNode;
+    enumName: string;
+    enumValues: ParsedEnumValuesMap;
+    futureProofEnums: boolean;
+    ignoreEnumValuesFromSchema: boolean;
+    naming: {
+        convert: ConvertFn;
+        typesPrefix: string;
+        typesSuffix: string;
+        useTypesPrefix?: boolean;
+        useTypesSuffix?: boolean;
+    };
+    outputType: 'string-literal' | 'native-numeric' | 'const' | 'native-const' | 'native';
+    declarationBlockConfig: DeclarationBlockConfig;
+}
+export declare const convertSchemaEnumToDeclarationBlockString: ({ schema, node, enumName, enumValues, futureProofEnums, ignoreEnumValuesFromSchema, outputType, declarationBlockConfig, naming, }: ConvertSchemaEnumToDeclarationBlockString) => string;
+export declare const buildEnumValuesBlock: ({ typeName, values, schema, naming, ignoreEnumValuesFromSchema, declarationBlockConfig, enumValues, }: Pick<ConvertSchemaEnumToDeclarationBlockString, "schema" | "naming" | "ignoreEnumValuesFromSchema" | "declarationBlockConfig" | "enumValues"> & {
+    typeName: string;
+    values: ReadonlyArray<EnumValueDefinitionNode>;
+}) => string;

package/typings/graphql-type-utils.d.cts

@@ -0,0 +1,2 @@
+import { type GraphQLNamedType } from 'graphql';
+export declare const isNativeNamedType: (namedType: GraphQLNamedType) => boolean;

package/typings/graphql-type-utils.d.ts

@@ -0,0 +1,2 @@
+import { type GraphQLNamedType } from 'graphql';
+export declare const isNativeNamedType: (namedType: GraphQLNamedType) => boolean;

package/typings/imports.d.cts

@@ -1,11 +1,11 @@
+import type { ParsedEnumValuesMap } from './types';
 export type ImportDeclaration<T = string> = {
     outputPath: string;
     importSource: ImportSource<T>;
     baseOutputDir: string;
     baseDir: string;
     typesImport: boolean;
-    emitLegacyCommonJSImports?: boolean;
-    importExtension: '' | `.${string}`;
+    emitLegacyCommonJSImports: boolean;
 };
 export type ImportSource<T = string> = {
     /**
@@ -31,3 +31,13 @@ export declare function resolveRelativeImport(from: string, to: string): string;
 export declare function resolveImportSource<T>(source: string | ImportSource<T>): ImportSource<T>;
 export declare function clearExtension(path: string): string;
 export declare function fixLocalFilePath(path: string): string;
+export declare function getEnumsImports({ enumValues, useTypeImports, }: {
+    enumValues: ParsedEnumValuesMap;
+    useTypeImports: boolean;
+}): string[];
+export declare function buildTypeImport({ identifier, source, useTypeImports, asDefault, }: {
+    identifier: string;
+    source: string;
+    useTypeImports: boolean;
+    asDefault?: boolean;
+}): string;

package/typings/imports.d.ts

@@ -1,11 +1,11 @@
+import type { ParsedEnumValuesMap } from './types';
 export type ImportDeclaration<T = string> = {
     outputPath: string;
     importSource: ImportSource<T>;
     baseOutputDir: string;
     baseDir: string;
     typesImport: boolean;
-    emitLegacyCommonJSImports?: boolean;
-    importExtension: '' | `.${string}`;
+    emitLegacyCommonJSImports: boolean;
 };
 export type ImportSource<T = string> = {
     /**
@@ -31,3 +31,13 @@ export declare function resolveRelativeImport(from: string, to: string): string;
 export declare function resolveImportSource<T>(source: string | ImportSource<T>): ImportSource<T>;
 export declare function clearExtension(path: string): string;
 export declare function fixLocalFilePath(path: string): string;
+export declare function getEnumsImports({ enumValues, useTypeImports, }: {
+    enumValues: ParsedEnumValuesMap;
+    useTypeImports: boolean;
+}): string[];
+export declare function buildTypeImport({ identifier, source, useTypeImports, asDefault, }: {
+    identifier: string;
+    source: string;
+    useTypeImports: boolean;
+    asDefault?: boolean;
+}): string;

package/typings/index.d.cts

@@ -17,3 +17,5 @@ export * from './selection-set-to-object.cjs';
 export * from './types.cjs';
 export * from './utils.cjs';
 export * from './variables-to-object.cjs';
+export * from './convert-schema-enum-to-declaration-block-string.cjs';
+export * from './graphql-type-utils.cjs';

package/typings/index.d.ts

@@ -17,3 +17,5 @@ export * from './selection-set-to-object.js';
 export * from './types.js';
 export * from './utils.js';
 export * from './variables-to-object.js';
+export * from './convert-schema-enum-to-declaration-block-string.js';
+export * from './graphql-type-utils.js';

package/typings/selection-set-processor/base.d.cts

@@ -1,5 +1,5 @@
 import { GraphQLInterfaceType, GraphQLNamedType, GraphQLObjectType, GraphQLOutputType, Location } from 'graphql';
-import { AvoidOptionalsConfig, ConvertNameFn, NormalizedScalarsMap } from '../types.cjs';
+import { ConvertNameFn, NormalizedScalarsMap } from '../types.cjs';
 export type PrimitiveField = {
     isConditional: boolean;
     fieldName: string;
@@ -26,9 +26,11 @@ export type SelectionSetProcessorConfig = {
     enumPrefix: boolean | null;
     enumSuffix: boolean | null;
     scalars: NormalizedScalarsMap;
-    formatNamedField(name: string, type?: GraphQLOutputType | GraphQLNamedType | null, isConditional?: boolean, isOptional?: boolean): string;
+    formatNamedField(params: {
+        name: string;
+        isOptional?: boolean;
+    }): string;
     wrapTypeWithModifiers(baseType: string, type: GraphQLOutputType | GraphQLNamedType): string;
-    avoidOptionals?: AvoidOptionalsConfig | boolean;
     printFieldsOnNewLines?: boolean;
 };
 export declare class BaseSelectionSetProcessor<Config extends SelectionSetProcessorConfig> {