Type System and Configuration

/**
 * Scalars map configuration - can be a simple string for default mapping
 * or an object with detailed scalar mappings
 */
type ScalarsMap = string | { [name: string]: string | { input: string; output: string } };

/**
 * Normalized scalars map with explicit input and output types
 */
interface NormalizedScalarsMap {
  [name: string]: {
    input: string;
    output: string;
  };
}

/**
 * Parsed scalars map with complete mapper objects for code generation
 */
interface ParsedScalarsMap {
  [name: string]: {
    input: ParsedMapper;
    output: ParsedMapper;
  };
}

/**
 * Default scalar mappings for common GraphQL scalars
 */
const DEFAULT_SCALARS: NormalizedScalarsMap;

// Simple string mapping for default types
const simpleScalars: ScalarsMap = {
  DateTime: 'Date',
  JSON: 'any',
  Upload: 'File'
};

// Complex input/output mappings
const complexScalars: ScalarsMap = {
  DateTime: {
    input: 'Date | string',
    output: 'Date'
  },
  BigInt: {
    input: 'number | string | bigint',
    output: 'bigint'
  }
};

/**
 * Naming convention configuration - can be a string path, function, or configuration object
 */
type NamingConvention = string | NamingConventionFn | NamingConventionMap;

/**
 * Function type for custom naming transformations
 */
type NamingConventionFn = (str: string) => string;

/**
 * String path to a module and method for naming convention
 */
type NamingConventionResolvePath = string;

/**
 * Map of naming conventions for different output types
 */
interface NamingConventionMap {
  /** Naming convention for enum values */
  enumValues?: 'keep' | NamingConventionResolvePath | NamingConventionFn;
  /** Naming convention for type names */  
  typeNames?: 'keep' | NamingConventionResolvePath | NamingConventionFn;
  /** Whether to transform underscores */
  transformUnderscore?: boolean;
}

/**
 * Name conversion function type with optional configuration
 */
type ConvertFn<T = {}> = (node: ASTNode | string, options?: ConvertOptions & T) => string;

/**
 * Name conversion function specifically for names
 */
type ConvertNameFn<T = {}> = ConvertFn<T>;

/**
 * Options for name conversion operations
 */
interface ConvertOptions {
  prefix?: string;
  suffix?: string;
  transformUnderscore?: boolean;
}

// String-based naming convention using change-case-all
const naming1: NamingConvention = 'change-case-all#pascalCase';

// Custom naming function
const naming2: NamingConvention = (str: string) => str.toUpperCase();

// Detailed naming configuration
const naming3: NamingConventionMap = {
  typeNames: 'change-case-all#pascalCase',
  enumValues: 'keep',
  transformUnderscore: true
};

/**
 * Raw configuration for enum values - can be a file path, enum mappings, or explicit values
 */
type EnumValuesMap<AdditionalProps = {}> =
  | string
  | { [enumName: string]: string | ({ [key: string]: string | number } & AdditionalProps) };

/**
 * Parsed enum values map with complete type information
 */
interface ParsedEnumValuesMap {
  [enumName: string]: {
    /** Explicitly mapped enum values */
    mappedValues?: { [valueName: string]: string | number };
    /** GraphQL enum name */
    typeIdentifier: string;
    /** Actual identifier to use in code */
    sourceIdentifier?: string;
    /** Source file path for external enums */
    sourceFile?: string;
    /** Import expression for external enums */
    importIdentifier?: string;
    /** Whether default import is used */
    isDefault?: boolean;
  };
}

/**
 * TypeScript declaration kinds
 */
type DeclarationKind = 'type' | 'interface' | 'class' | 'abstract class';

/**
 * Configuration for declaration kinds by GraphQL schema element type
 */
interface DeclarationKindConfig {
  /** Declaration kind for directive types */
  directive?: DeclarationKind;
  /** Declaration kind for scalar types */
  scalar?: DeclarationKind;
  /** Declaration kind for input types */
  input?: DeclarationKind;
  /** Declaration kind for object types */
  type?: DeclarationKind;
  /** Declaration kind for interface types */
  interface?: DeclarationKind;
  /** Declaration kind for argument types */
  arguments?: DeclarationKind;
}

/**
 * Default declaration kind mappings
 */
const DEFAULT_DECLARATION_KINDS: DeclarationKindConfig;

/**
 * Configuration for avoiding optional field modifiers
 */
interface AvoidOptionalsConfig {
  /** Avoid optionals on field definitions */
  field?: boolean;
  /** Avoid optionals on object types */
  object?: boolean;
  /** Avoid optionals on input values */
  inputValue?: boolean;
  /** Avoid optionals on default values */
  defaultValue?: boolean;
  /** Avoid optionals on resolver types */
  resolvers?: boolean;
}

/**
 * Default avoid optionals configuration
 */
const DEFAULT_AVOID_OPTIONALS: AvoidOptionalsConfig;

/**
 * Configuration for non-optional __typename fields
 */
interface ResolversNonOptionalTypenameConfig {
  /** Make __typename non-optional on union members */
  unionMember?: boolean;
  /** Make __typename non-optional on interface implementing types */
  interfaceImplementingType?: boolean;
  /** Exclude specific types from non-optional __typename */
  excludeTypes?: string[];
}

/**
 * Union type for all mapper configurations
 */
type ParsedMapper = InternalParsedMapper | ExternalParsedMapper;

/**
 * External mapper pointing to types from other modules
 */
interface ExternalParsedMapper {
  isExternal: true;
  type: string;
  source: string;
  import: string;
  default?: boolean;
}

/**
 * Internal mapper using locally defined types
 */
interface InternalParsedMapper {
  isExternal: false;
  type: string;
}

/**
 * Raw directive argument and input field mappings
 */
type DirectiveArgumentAndInputFieldMappings = { [name: string]: string };

/**
 * Parsed directive mappings with complete mapper objects
 */
type ParsedDirectiveArgumentAndInputFieldMappings = { [name: string]: ParsedMapper };

/**
 * Loaded fragment with metadata for code generation
 */
type LoadedFragment<AdditionalFields = {}> = {
  name: string;
  onType: string;
  node: FragmentDefinitionNode;
  isExternal: boolean;
  importFrom?: string | null;
} & AdditionalFields;

/**
 * Fragment directive information
 */
interface FragmentDirectives {
  fragmentDirectives?: Array<DirectiveNode>;
}

/**
 * Parsed import information for code generation
 */
interface ParsedImport {
  moduleName: string | null;
  propName: string;
}

/**
 * Function type for getting fragment suffixes
 */
type GetFragmentSuffixFn = (node: FragmentDefinitionNode | string) => string;

/**
 * Creates a name conversion function from naming convention configuration
 * @param config - Naming convention configuration
 * @returns Conversion function
 */
function convertFactory(config: { namingConvention?: NamingConvention }): ConvertFn;

/**
 * Parses enum values configuration into normalized format
 * @param options - Enum parsing options
 * @returns Parsed enum values map
 */
function parseEnumValues(options: {
  schema: GraphQLSchema;
  mappers: EnumValuesMap;
  ignoreEnumValuesFromSchema?: boolean;
  convertName: ConvertFn;
  suffix?: string;
}): ParsedEnumValuesMap;

/**
 * Normalizes declaration kind configuration
 * @param declarationKind - Declaration kind configuration
 * @returns Normalized declaration kind config
 */
function normalizeDeclarationKind(
  declarationKind: DeclarationKind | DeclarationKindConfig | undefined
): DeclarationKindConfig;

/**
 * Normalizes avoid optionals configuration
 * @param avoidOptionals - Avoid optionals configuration
 * @returns Normalized avoid optionals config
 */
function normalizeAvoidOptionals(
  avoidOptionals: boolean | AvoidOptionalsConfig | undefined
): AvoidOptionalsConfig;

import {
  convertFactory,
  parseEnumValues,
  normalizeDeclarationKind,
  DEFAULT_SCALARS
} from "@graphql-codegen/visitor-plugin-common";

// Create a custom name converter
const convertName = convertFactory({
  namingConvention: {
    typeNames: 'change-case-all#pascalCase',
    enumValues: 'change-case-all#upperCase',
    transformUnderscore: true
  }
});

// Parse enum values configuration
const enumValues = parseEnumValues({
  schema,
  mappers: {
    Status: { ACTIVE: 1, INACTIVE: 0 },
    Role: './types#UserRole'
  },
  convertName,
  suffix: 'Enum'
});

// Configure declaration kinds
const declarationKind = normalizeDeclarationKind({
  type: 'interface',
  input: 'interface',
  scalar: 'type',
  enum: 'enum'
});