@gqlkit-ts/cli 0.1.0 → 0.3.0

package/src/auto-type-generator/auto-type-generator.ts

@@ -0,0 +1,1670 @@
+import type ts from "typescript";
+import type {
+  ExtractResolversResult,
+  GraphQLFieldDefinition,
+} from "../resolver-extractor/index.js";
+import type {
+  DirectiveArgumentValue,
+  DirectiveInfo,
+} from "../shared/directive-detector.js";
+import {
+  detectEnumPrefix,
+  stripEnumPrefix,
+} from "../shared/enum-prefix-detector.js";
+import { getSourceLocationOrDefault } from "../shared/source-location.js";
+import type { DeprecationInfo } from "../shared/tsdoc-parser.js";
+import { convertTsTypeToGraphQLType } from "../shared/type-converter.js";
+import {
+  isEligibleAsInputObjectField,
+  isEligibleAsObjectField,
+} from "../type-extractor/converter/field-eligibility.js";
+import {
+  createReferenceType,
+  type Diagnostic,
+  type ExtractedTypeInfo,
+  type FieldDefinition,
+  type GraphQLFieldType,
+  type InlineEnumMemberInfo,
+  type InlineObjectPropertyDef,
+  type SourceLocation,
+} from "../type-extractor/types/index.js";
+import {
+  collectInlineEnumsFromPayloads,
+  collectInlineEnumsFromResolvers,
+  collectInlineEnumsFromTypes,
+  type InlineEnumWithContext,
+} from "./inline-enum-collector.js";
+import {
+  collectInlineUnionsFromPayloads,
+  collectInlineUnionsFromResolvers,
+  collectInlineUnionsFromTypes,
+  type InlineUnionWithContext,
+} from "./inline-union-collector.js";
+import type { InlineUnionMemberInfo } from "./inline-union-types.js";
+import {
+  type ValidatedTypenameInfo,
+  validateOneOfMembers,
+  validateUnionMembers,
+  validateUnionMemberTypenames,
+} from "./inline-union-validator.js";
+import {
+  type AutoTypeNameContext,
+  buildFieldContext,
+  generateAutoTypeName,
+  isInputTypeName,
+} from "./naming-convention.js";
+import type { ResolveTypeFieldPattern } from "./resolve-type-generator.js";
+import { forEachResolverField } from "./resolver-field-iterator.js";
+import {
+  createFieldNameSet,
+  findTypenameProperty,
+  type TypenameFieldInfo,
+  type TypenameFieldName,
+} from "./typename-types.js";
+
+/**
+ * Information about where an auto-generated type was generated from.
+ */
+export interface GeneratedFromInfo {
+  readonly parentTypeName: string | null;
+  readonly fieldPath: ReadonlyArray<string>;
+  readonly context:
+    | "typeField"
+    | "inputField"
+    | "resolverArg"
+    | "resolverPayload";
+}
+
+/**
+ * Field information for auto-generated types.
+ */
+export interface AutoGeneratedField {
+  readonly name: string;
+  readonly type: GraphQLFieldType;
+  readonly description: string | null;
+  readonly deprecated: DeprecationInfo | null;
+  readonly directives: ReadonlyArray<DirectiveInfo> | null;
+  readonly defaultValue: DirectiveArgumentValue | null;
+}
+
+/**
+ * Enum value information for auto-generated enum types.
+ */
+export interface AutoGeneratedEnumValue {
+  /** GraphQL enum value name (SCREAMING_SNAKE_CASE) */
+  readonly name: string;
+  /** Original TypeScript value */
+  readonly originalValue: string;
+  readonly description: string | null;
+  readonly deprecated: DeprecationInfo | null;
+}
+
+/**
+ * Auto-generated type information.
+ */
+export interface AutoGeneratedType {
+  readonly name: string;
+  readonly kind:
+    | "Object"
+    | "InputObject"
+    | "Enum"
+    | "Union"
+    | "OneOfInputObject";
+  /** Fields for Object/InputObject/OneOfInputObject kinds (null for Enum/Union) */
+  readonly fields: ReadonlyArray<AutoGeneratedField> | null;
+  /** Enum values for Enum kind (null for Object/InputObject/Union/OneOfInputObject) */
+  readonly enumValues: ReadonlyArray<AutoGeneratedEnumValue> | null;
+  /** Union members for Union kind (null for Object/InputObject/Enum/OneOfInputObject) */
+  readonly unionMembers: ReadonlyArray<string> | null;
+  /** True if enum needs value mapping (at least one value converted) */
+  readonly needsStringEnumMapping: boolean;
+  readonly sourceLocation: SourceLocation;
+  readonly generatedFrom: GeneratedFromInfo;
+  readonly description: string | null;
+  /** For Union types from resolverPayload context: the field pattern for resolveType */
+  readonly resolveTypeFieldPattern: ResolveTypeFieldPattern | null;
+}
+
+export interface AutoTypeGeneratorInput {
+  readonly extractedTypes: ReadonlyArray<ExtractedTypeInfo>;
+  readonly resolversResult: ExtractResolversResult;
+  readonly knownTypeNames: ReadonlySet<string>;
+}
+
+export interface AutoTypeGeneratorResult {
+  readonly autoGeneratedTypes: ReadonlyArray<AutoGeneratedType>;
+  readonly updatedExtractedTypes: ReadonlyArray<ExtractedTypeInfo>;
+  readonly updatedResolversResult: ExtractResolversResult;
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+}
+
+interface InlineObjectWithContext {
+  readonly properties: ReadonlyArray<InlineObjectPropertyDef>;
+  readonly context: AutoTypeNameContext;
+  readonly sourceLocation: SourceLocation;
+  readonly nullable: boolean;
+  /** TSDoc description from the inline object type alias (Requirement 7.2) */
+  readonly description: string | null;
+  /** @deprecated tag from the inline object type alias (Requirement 7.3) */
+  readonly deprecated: DeprecationInfo | null;
+}
+
+type ContextBuilderFn = (
+  nestedPath: ReadonlyArray<string>,
+) => AutoTypeNameContext;
+
+interface ExtractNestedInlineObjectsParams {
+  readonly properties: ReadonlyArray<InlineObjectPropertyDef>;
+  readonly currentPath: ReadonlyArray<string>;
+  readonly sourceLocation: SourceLocation;
+  readonly buildContext: ContextBuilderFn;
+  readonly preserveDocumentation: boolean;
+  readonly results: InlineObjectWithContext[];
+}
+
+function extractNestedInlineObjectsRecursively(
+  params: ExtractNestedInlineObjectsParams,
+): void {
+  const {
+    properties,
+    currentPath,
+    sourceLocation,
+    buildContext,
+    preserveDocumentation,
+    results,
+  } = params;
+
+  for (const prop of properties) {
+    if (
+      prop.tsType.kind === "inlineObject" &&
+      prop.tsType.inlineObjectProperties
+    ) {
+      const nestedPath = [...currentPath, prop.name];
+      const nestedContext = buildContext(nestedPath);
+      // Use property's source location if available for more accurate diagnostics
+      const nestedSourceLocation = prop.sourceLocation ?? sourceLocation;
+
+      results.push({
+        properties: prop.tsType.inlineObjectProperties,
+        context: nestedContext,
+        sourceLocation: nestedSourceLocation,
+        nullable: prop.tsType.nullable,
+        description: preserveDocumentation
+          ? prop.tsType.inlineObjectDescription
+          : null,
+        deprecated: preserveDocumentation
+          ? prop.tsType.inlineObjectDeprecated
+          : null,
+      });
+
+      extractNestedInlineObjectsRecursively({
+        properties: prop.tsType.inlineObjectProperties,
+        currentPath: nestedPath,
+        sourceLocation: nestedSourceLocation,
+        buildContext,
+        preserveDocumentation,
+        results,
+      });
+    }
+  }
+}
+
+function getContextKey(context: AutoTypeNameContext): string {
+  switch (context.kind) {
+    case "objectField":
+      return `objectField:${context.parentTypeName}:${context.fieldPath.join(".")}`;
+    case "inputField":
+      return `inputField:${context.parentTypeName}:${context.fieldPath.join(".")}`;
+    case "resolverArg":
+      return `resolverArg:${context.resolverType}:${context.parentTypeName ?? ""}:${context.fieldName}:${context.argName}:${context.fieldPath.join(".")}`;
+    case "resolverPayload":
+      return `resolverPayload:${context.resolverType}:${context.parentTypeName ?? ""}:${context.fieldName}:${context.fieldPath.join(".")}`;
+  }
+}
+
+function mapContextKindToGeneratedFromContext(
+  kind: AutoTypeNameContext["kind"],
+): GeneratedFromInfo["context"] {
+  switch (kind) {
+    case "objectField":
+      return "typeField";
+    case "inputField":
+      return "inputField";
+    case "resolverArg":
+      return "resolverArg";
+    case "resolverPayload":
+      return "resolverPayload";
+  }
+}
+
+function buildGeneratedFromInfo(
+  context: AutoTypeNameContext,
+): GeneratedFromInfo {
+  const fieldPath =
+    context.kind === "resolverArg" && context.fieldPath.length === 0
+      ? [context.argName]
+      : context.fieldPath;
+
+  return {
+    parentTypeName: context.parentTypeName,
+    fieldPath,
+    context: mapContextKindToGeneratedFromContext(context.kind),
+  };
+}
+
+function collectInlineObjectsFromType(
+  typeInfo: ExtractedTypeInfo,
+): InlineObjectWithContext[] {
+  const results: InlineObjectWithContext[] = [];
+  const isInput = isInputTypeName(typeInfo.metadata.name);
+
+  for (const field of typeInfo.fields) {
+    collectInlineObjectsFromField(
+      field,
+      typeInfo.metadata.name,
+      [],
+      isInput,
+      typeInfo.metadata.sourceFile,
+      results,
+    );
+  }
+
+  return results;
+}
+
+function collectInlineObjectsFromField(
+  field: FieldDefinition,
+  parentTypeName: string,
+  parentPath: ReadonlyArray<string>,
+  isInput: boolean,
+  sourceFile: string,
+  results: InlineObjectWithContext[],
+): void {
+  const tsType = field.tsType;
+
+  if (tsType.kind !== "inlineObject" || !tsType.inlineObjectProperties) {
+    return;
+  }
+
+  const fieldPath = [...parentPath, field.name];
+
+  const context: AutoTypeNameContext = isInput
+    ? {
+        kind: "inputField",
+        parentTypeName,
+        fieldPath,
+      }
+    : {
+        kind: "objectField",
+        parentTypeName,
+        fieldPath,
+      };
+
+  const sourceLocation = getSourceLocationOrDefault(
+    field.sourceLocation,
+    sourceFile,
+  );
+
+  results.push({
+    properties: tsType.inlineObjectProperties,
+    context,
+    sourceLocation,
+    nullable: tsType.nullable,
+    description: tsType.inlineObjectDescription,
+    deprecated: tsType.inlineObjectDeprecated,
+  });
+
+  extractNestedInlineObjectsRecursively({
+    properties: tsType.inlineObjectProperties,
+    currentPath: fieldPath,
+    sourceLocation,
+    buildContext: (nestedPath) =>
+      isInput
+        ? { kind: "inputField", parentTypeName, fieldPath: nestedPath }
+        : { kind: "objectField", parentTypeName, fieldPath: nestedPath },
+    preserveDocumentation: true,
+    results,
+  });
+}
+
+function collectInlineObjectsFromResolvers(
+  resolversResult: ExtractResolversResult,
+): InlineObjectWithContext[] {
+  const results: InlineObjectWithContext[] = [];
+
+  forEachResolverField(
+    resolversResult,
+    ({ field, resolverType, parentTypeName }) => {
+      collectInlineObjectsFromResolverArgs(
+        field,
+        resolverType,
+        parentTypeName,
+        results,
+      );
+    },
+  );
+
+  return results;
+}
+
+function collectInlineObjectsFromResolverArgs(
+  field: GraphQLFieldDefinition,
+  resolverType: "query" | "mutation" | "field",
+  parentTypeName: string | null,
+  results: InlineObjectWithContext[],
+): void {
+  if (!field.args) return;
+
+  for (const arg of field.args) {
+    if (!arg.inlineObjectProperties) continue;
+
+    const context: AutoTypeNameContext = {
+      kind: "resolverArg",
+      resolverType,
+      fieldName: field.name,
+      argName: arg.name,
+      parentTypeName,
+      fieldPath: [],
+    };
+
+    results.push({
+      properties: arg.inlineObjectProperties,
+      context,
+      sourceLocation: field.sourceLocation,
+      nullable: arg.type.nullable,
+      description: null,
+      deprecated: null,
+    });
+
+    extractNestedInlineObjectsRecursively({
+      properties: arg.inlineObjectProperties,
+      currentPath: [],
+      sourceLocation: field.sourceLocation,
+      buildContext: (nestedPath) => ({
+        kind: "resolverArg",
+        resolverType,
+        fieldName: field.name,
+        argName: arg.name,
+        parentTypeName,
+        fieldPath: nestedPath,
+      }),
+      preserveDocumentation: false,
+      results,
+    });
+  }
+}
+
+function collectInlinePayloadsFromResolvers(
+  resolversResult: ExtractResolversResult,
+): InlineObjectWithContext[] {
+  const results: InlineObjectWithContext[] = [];
+
+  forEachResolverField(
+    resolversResult,
+    ({ field, resolverType, parentTypeName }) => {
+      collectInlinePayloadFromReturnType(
+        field,
+        resolverType,
+        parentTypeName,
+        results,
+      );
+    },
+  );
+
+  return results;
+}
+
+function collectInlinePayloadFromReturnType(
+  field: GraphQLFieldDefinition,
+  resolverType: "query" | "mutation" | "field",
+  parentTypeName: string | null,
+  results: InlineObjectWithContext[],
+): void {
+  if (!field.returnTypeInlineObjectProperties) return;
+
+  const context: AutoTypeNameContext = {
+    kind: "resolverPayload",
+    resolverType,
+    fieldName: field.name,
+    parentTypeName,
+    fieldPath: [],
+  };
+
+  results.push({
+    properties: field.returnTypeInlineObjectProperties,
+    context,
+    sourceLocation: field.sourceLocation,
+    nullable: field.type.nullable,
+    description: field.returnTypeInlineObjectDescription,
+    deprecated: field.returnTypeInlineObjectDeprecated,
+  });
+
+  extractNestedInlineObjectsRecursively({
+    properties: field.returnTypeInlineObjectProperties,
+    currentPath: [],
+    sourceLocation: field.sourceLocation,
+    buildContext: (nestedPath) => ({
+      kind: "resolverPayload",
+      resolverType,
+      fieldName: field.name,
+      parentTypeName,
+      fieldPath: nestedPath,
+    }),
+    preserveDocumentation: true,
+    results,
+  });
+}
+
+interface GenerateAutoTypeResult {
+  readonly type: AutoGeneratedType;
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+}
+
+interface GenerateAutoTypeParams {
+  readonly inlineObj: InlineObjectWithContext;
+  readonly generatedTypeNames: Map<string, string>;
+  readonly enumTypeNames: Map<string, string>;
+  readonly unionTypeNames: Map<string, string>;
+}
+
+function generateAutoType(
+  params: GenerateAutoTypeParams,
+): GenerateAutoTypeResult {
+  const { inlineObj, generatedTypeNames, enumTypeNames, unionTypeNames } =
+    params;
+  const name = generateAutoTypeName(inlineObj.context);
+  const isInput =
+    inlineObj.context.kind === "inputField" ||
+    inlineObj.context.kind === "resolverArg";
+
+  const fields: AutoGeneratedField[] = [];
+  const diagnostics: Diagnostic[] = [];
+
+  for (const prop of inlineObj.properties) {
+    const eligibility = isInput
+      ? isEligibleAsInputObjectField(prop.name)
+      : isEligibleAsObjectField(prop.name);
+
+    if (!eligibility.eligible) {
+      diagnostics.push({
+        code: "SKIPPED_FIELD",
+        message: eligibility.skipReason.message,
+        severity: "warning",
+        location: prop.sourceLocation ?? inlineObj.sourceLocation,
+      });
+      continue;
+    }
+
+    const fieldType = resolveFieldType({
+      prop,
+      generatedTypeNames,
+      enumTypeNames,
+      unionTypeNames,
+      parentContext: inlineObj.context,
+    });
+    fields.push({
+      name: prop.name,
+      type: fieldType,
+      description: prop.description,
+      deprecated: prop.deprecated,
+      directives: prop.directives,
+      defaultValue: prop.defaultValue,
+    });
+  }
+
+  return {
+    type: {
+      name,
+      kind: isInput ? "InputObject" : "Object",
+      fields,
+      enumValues: null,
+      unionMembers: null,
+      needsStringEnumMapping: false,
+      sourceLocation: inlineObj.sourceLocation,
+      generatedFrom: buildGeneratedFromInfo(inlineObj.context),
+      description: inlineObj.description,
+      resolveTypeFieldPattern: null,
+    },
+    diagnostics,
+  };
+}
+
+interface ResolveFieldTypeParams {
+  readonly prop: InlineObjectPropertyDef;
+  readonly generatedTypeNames: Map<string, string>;
+  readonly enumTypeNames: Map<string, string>;
+  readonly unionTypeNames: Map<string, string>;
+  readonly parentContext: AutoTypeNameContext;
+}
+
+function tryResolveNestedType(
+  prop: InlineObjectPropertyDef,
+  parentContext: AutoTypeNameContext,
+  typeNamesMap: ReadonlyMap<string, string>,
+): GraphQLFieldType | null {
+  const nestedPath = [...parentContext.fieldPath, prop.name];
+  const nestedContext: AutoTypeNameContext = {
+    ...parentContext,
+    fieldPath: nestedPath,
+  };
+  const contextKey = getContextKey(nestedContext);
+  const resolvedTypeName = typeNamesMap.get(contextKey);
+
+  if (resolvedTypeName) {
+    return {
+      typeName: resolvedTypeName,
+      nullable: prop.tsType.nullable || prop.optional,
+      list: false,
+      listItemNullable: null,
+    };
+  }
+  return null;
+}
+
+function resolveFieldType(params: ResolveFieldTypeParams): GraphQLFieldType {
+  const {
+    prop,
+    generatedTypeNames,
+    enumTypeNames,
+    unionTypeNames,
+    parentContext,
+  } = params;
+
+  if (
+    prop.tsType.kind === "inlineObject" &&
+    prop.tsType.inlineObjectProperties
+  ) {
+    const result = tryResolveNestedType(
+      prop,
+      parentContext,
+      generatedTypeNames,
+    );
+    if (result) return result;
+  }
+
+  if (prop.tsType.kind === "inlineEnum" && prop.tsType.inlineEnumMembers) {
+    const result = tryResolveNestedType(prop, parentContext, enumTypeNames);
+    if (result) return result;
+  }
+
+  if (prop.tsType.kind === "union" && prop.tsType.members) {
+    const result = tryResolveNestedType(prop, parentContext, unionTypeNames);
+    if (result) return result;
+  }
+
+  return convertTsTypeToGraphQLType(prop.tsType, prop.optional);
+}
+
+interface UpdateTypeNamesParams {
+  readonly generatedTypeNames: Map<string, string>;
+  readonly enumTypeNames: Map<string, string>;
+  readonly unionTypeNames: Map<string, string>;
+}
+
+function updateExtractedTypes(
+  extractedTypes: ReadonlyArray<ExtractedTypeInfo>,
+  params: UpdateTypeNamesParams,
+): ExtractedTypeInfo[] {
+  return extractedTypes.map((typeInfo) => {
+    const isInput = isInputTypeName(typeInfo.metadata.name);
+    return {
+      ...typeInfo,
+      fields: typeInfo.fields.map((field) =>
+        updateField(field, params, typeInfo.metadata.name, isInput),
+      ),
+    };
+  });
+}
+
+function updateField(
+  field: FieldDefinition,
+  params: UpdateTypeNamesParams,
+  parentTypeName: string,
+  isInput: boolean,
+): FieldDefinition {
+  const { generatedTypeNames, enumTypeNames, unionTypeNames } = params;
+  const context = buildFieldContext(parentTypeName, [field.name], isInput);
+  const contextKey = getContextKey(context);
+
+  // Handle inline objects
+  if (
+    field.tsType.kind === "inlineObject" &&
+    field.tsType.inlineObjectProperties
+  ) {
+    const resolvedTypeName = generatedTypeNames.get(contextKey);
+    if (resolvedTypeName) {
+      return {
+        ...field,
+        tsType: createReferenceType({
+          name: resolvedTypeName,
+          nullable: field.tsType.nullable,
+        }),
+      };
+    }
+  }
+
+  // Handle inline enums
+  if (field.tsType.kind === "inlineEnum" && field.tsType.inlineEnumMembers) {
+    const resolvedTypeName = enumTypeNames.get(contextKey);
+    if (resolvedTypeName) {
+      return {
+        ...field,
+        tsType: createReferenceType({
+          name: resolvedTypeName,
+          nullable: field.tsType.nullable,
+        }),
+      };
+    }
+  }
+
+  // Handle array of inline enums
+  if (
+    field.tsType.kind === "array" &&
+    field.tsType.elementType?.kind === "inlineEnum" &&
+    field.tsType.elementType.inlineEnumMembers
+  ) {
+    const resolvedTypeName = enumTypeNames.get(contextKey);
+    if (resolvedTypeName) {
+      return {
+        ...field,
+        tsType: {
+          ...field.tsType,
+          elementType: createReferenceType({
+            name: resolvedTypeName,
+            nullable: field.tsType.elementType.nullable,
+          }),
+        },
+      };
+    }
+  }
+
+  // Handle inline union types
+  if (field.tsType.kind === "union" && field.tsType.members) {
+    const resolvedTypeName = unionTypeNames.get(contextKey);
+    if (resolvedTypeName) {
+      return {
+        ...field,
+        tsType: createReferenceType({
+          name: resolvedTypeName,
+          nullable: field.tsType.nullable,
+        }),
+      };
+    }
+  }
+
+  return field;
+}
+
+function updateResolversResult(
+  resolversResult: ExtractResolversResult,
+  params: UpdateTypeNamesParams,
+): ExtractResolversResult {
+  return {
+    ...resolversResult,
+    queryFields: {
+      fields: resolversResult.queryFields.fields.map((field) =>
+        updateResolverField(field, params, "query", null),
+      ),
+    },
+    mutationFields: {
+      fields: resolversResult.mutationFields.fields.map((field) =>
+        updateResolverField(field, params, "mutation", null),
+      ),
+    },
+    typeExtensions: resolversResult.typeExtensions.map((ext) => ({
+      ...ext,
+      fields: ext.fields.map((field) =>
+        updateResolverField(field, params, "field", ext.targetTypeName),
+      ),
+    })),
+  };
+}
+
+function updateResolverField(
+  field: GraphQLFieldDefinition,
+  params: UpdateTypeNamesParams,
+  resolverType: "query" | "mutation" | "field",
+  parentTypeName: string | null,
+): GraphQLFieldDefinition {
+  const { generatedTypeNames, enumTypeNames, unionTypeNames } = params;
+
+  let updatedType = field.type;
+
+  // Create payload context once for all inline return type checks
+  const hasInlinePayload =
+    field.returnTypeInlineObjectProperties ||
+    field.returnTypeInlineEnumMembers ||
+    field.returnTypeInlineUnionMembers;
+
+  if (hasInlinePayload) {
+    const payloadContext: AutoTypeNameContext = {
+      kind: "resolverPayload",
+      resolverType,
+      fieldName: field.name,
+      parentTypeName,
+      fieldPath: [],
+    };
+    const payloadContextKey = getContextKey(payloadContext);
+
+    // These are mutually exclusive - a return type can only be one of:
+    // inline object, inline enum, or inline union
+    if (field.returnTypeInlineObjectProperties) {
+      // Handle inline payload objects in return type
+      const resolvedTypeName = generatedTypeNames.get(payloadContextKey);
+      if (resolvedTypeName) {
+        updatedType = { ...field.type, typeName: resolvedTypeName };
+      }
+    } else if (field.returnTypeInlineEnumMembers) {
+      // Handle inline enum in return type
+      const resolvedTypeName = enumTypeNames.get(payloadContextKey);
+      if (resolvedTypeName) {
+        updatedType = { ...field.type, typeName: resolvedTypeName };
+      }
+    } else if (field.returnTypeInlineUnionMembers) {
+      // Handle inline union in return type
+      const resolvedTypeName = unionTypeNames.get(payloadContextKey);
+      if (resolvedTypeName) {
+        updatedType = { ...field.type, typeName: resolvedTypeName };
+      }
+    }
+  }
+
+  if (!field.args) {
+    return {
+      ...field,
+      type: updatedType,
+    };
+  }
+
+  const updatedArgs = field.args.map((arg) => {
+    const context: AutoTypeNameContext = {
+      kind: "resolverArg",
+      resolverType,
+      fieldName: field.name,
+      argName: arg.name,
+      parentTypeName,
+      fieldPath: [],
+    };
+    const contextKey = getContextKey(context);
+
+    // Handle inline objects
+    if (arg.inlineObjectProperties) {
+      const resolvedTypeName = generatedTypeNames.get(contextKey);
+      if (resolvedTypeName) {
+        return {
+          ...arg,
+          type: {
+            ...arg.type,
+            typeName: resolvedTypeName,
+          },
+        };
+      }
+    }
+
+    // Handle inline enums
+    if (arg.inlineEnumMembers) {
+      const resolvedTypeName = enumTypeNames.get(contextKey);
+      if (resolvedTypeName) {
+        return {
+          ...arg,
+          type: {
+            ...arg.type,
+            typeName: resolvedTypeName,
+          },
+        };
+      }
+    }
+
+    // Handle inline unions (OneOf input objects)
+    if (arg.inlineUnionMembers) {
+      const resolvedTypeName = unionTypeNames.get(contextKey);
+      if (resolvedTypeName) {
+        return {
+          ...arg,
+          type: {
+            ...arg.type,
+            typeName: resolvedTypeName,
+          },
+        };
+      }
+    }
+
+    return arg;
+  });
+
+  return {
+    ...field,
+    type: updatedType,
+    args: updatedArgs,
+  };
+}
+
+function buildGeneratedTypeNamesMap(
+  inlineObjects: InlineObjectWithContext[],
+): Map<string, string> {
+  const map = new Map<string, string>();
+
+  for (const inlineObj of inlineObjects) {
+    const typeName = generateAutoTypeName(inlineObj.context);
+    const contextKey = getContextKey(inlineObj.context);
+    map.set(contextKey, typeName);
+  }
+
+  return map;
+}
+
+function toScreamingSnakeCase(value: string): string {
+  return value
+    .replace(/[-\s]+/g, "_")
+    .replace(/([a-z])([A-Z])/g, "$1_$2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+    .toUpperCase();
+}
+
+interface ConvertInlineEnumMembersParams {
+  readonly members: ReadonlyArray<InlineEnumMemberInfo>;
+  readonly enumName: string;
+  readonly sourceLocation: SourceLocation;
+}
+
+interface ConvertEnumMembersWithDiagnosticsResult {
+  readonly enumValues: ReadonlyArray<AutoGeneratedEnumValue>;
+  readonly needsStringEnumMapping: boolean;
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+}
+
+interface ConvertedMemberInfo {
+  readonly convertedName: string;
+  readonly member: InlineEnumMemberInfo;
+}
+
+function convertInlineEnumMembers(
+  params: ConvertInlineEnumMembersParams,
+): ConvertEnumMembersWithDiagnosticsResult {
+  const { members, enumName, sourceLocation } = params;
+  let needsStringEnumMapping = false;
+  const enumValues: AutoGeneratedEnumValue[] = [];
+  const diagnostics: Diagnostic[] = [];
+
+  const convertedMembers: ConvertedMemberInfo[] = [];
+
+  for (const member of members) {
+    const convertedName = toScreamingSnakeCase(member.value);
+    convertedMembers.push({ convertedName, member });
+  }
+
+  const prefixDetectionResult = detectEnumPrefix({
+    enumName,
+    memberValues: convertedMembers.map((m) => m.convertedName),
+  });
+
+  const finalNameToOriginals = new Map<string, string[]>();
+
+  for (const { convertedName, member } of convertedMembers) {
+    let finalName = convertedName;
+    if (prefixDetectionResult.shouldStrip && prefixDetectionResult.prefix) {
+      finalName = stripEnumPrefix(convertedName, prefixDetectionResult.prefix);
+      needsStringEnumMapping = true;
+    } else if (convertedName !== member.value) {
+      needsStringEnumMapping = true;
+    }
+
+    const originals = finalNameToOriginals.get(finalName) ?? [];
+    originals.push(member.value);
+    finalNameToOriginals.set(finalName, originals);
+
+    enumValues.push({
+      name: finalName,
+      originalValue: member.value,
+      description: member.description,
+      deprecated: member.deprecated,
+    });
+  }
+
+  for (const [finalName, originals] of finalNameToOriginals) {
+    if (originals.length > 1) {
+      diagnostics.push({
+        code: "DUPLICATE_ENUM_VALUE_AFTER_CONVERSION",
+        message: `Enum '${enumName}' has duplicate value '${finalName}' after conversion (from '${originals.join("' and '")}')`,
+        severity: "error",
+        location: sourceLocation,
+      });
+    }
+  }
+
+  return { enumValues, needsStringEnumMapping, diagnostics };
+}
+
+interface GenerateAutoEnumTypeResult {
+  readonly type: AutoGeneratedType;
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+}
+
+function generateAutoEnumType(
+  inlineEnum: InlineEnumWithContext,
+  typeName: string,
+): GenerateAutoEnumTypeResult {
+  const { enumValues, needsStringEnumMapping, diagnostics } =
+    convertInlineEnumMembers({
+      members: inlineEnum.members,
+      enumName: typeName,
+      sourceLocation: inlineEnum.sourceLocation,
+    });
+
+  return {
+    type: {
+      name: typeName,
+      kind: "Enum",
+      fields: null,
+      enumValues,
+      unionMembers: null,
+      needsStringEnumMapping,
+      sourceLocation: inlineEnum.sourceLocation,
+      generatedFrom: buildGeneratedFromInfo(inlineEnum.context),
+      description: inlineEnum.externalEnumDescription,
+      resolveTypeFieldPattern: null,
+    },
+    diagnostics,
+  };
+}
+
+interface ExternalEnumRegistry {
+  readonly symbolToTypeName: Map<ts.Symbol, string>;
+  readonly symbolToContextKey: Map<ts.Symbol, string>;
+}
+
+interface BuildEnumTypeNamesMapResult {
+  readonly enumTypeNames: Map<string, string>;
+  readonly externalEnumRegistry: ExternalEnumRegistry;
+  readonly uniqueInlineEnums: InlineEnumWithContext[];
+}
+
+function buildEnumTypeNamesMap(
+  inlineEnums: InlineEnumWithContext[],
+): BuildEnumTypeNamesMapResult {
+  const enumTypeNames = new Map<string, string>();
+  const symbolToTypeName = new Map<ts.Symbol, string>();
+  const symbolToContextKey = new Map<ts.Symbol, string>();
+  const uniqueInlineEnums: InlineEnumWithContext[] = [];
+
+  for (const inlineEnum of inlineEnums) {
+    const contextKey = getContextKey(inlineEnum.context);
+
+    if (inlineEnum.externalEnumSymbol !== null) {
+      const existingTypeName = symbolToTypeName.get(
+        inlineEnum.externalEnumSymbol,
+      );
+      if (existingTypeName) {
+        enumTypeNames.set(contextKey, existingTypeName);
+        continue;
+      }
+
+      const typeName = generateAutoTypeName(inlineEnum.context);
+      symbolToTypeName.set(inlineEnum.externalEnumSymbol, typeName);
+      symbolToContextKey.set(inlineEnum.externalEnumSymbol, contextKey);
+      enumTypeNames.set(contextKey, typeName);
+      uniqueInlineEnums.push(inlineEnum);
+    } else {
+      const typeName = generateAutoTypeName(inlineEnum.context);
+      enumTypeNames.set(contextKey, typeName);
+      uniqueInlineEnums.push(inlineEnum);
+    }
+  }
+
+  return {
+    enumTypeNames,
+    externalEnumRegistry: { symbolToTypeName, symbolToContextKey },
+    uniqueInlineEnums,
+  };
+}
+
+function buildUnionTypeNamesMap(
+  inlineUnions: InlineUnionWithContext[],
+): Map<string, string> {
+  const unionTypeNames = new Map<string, string>();
+
+  for (const inlineUnion of inlineUnions) {
+    const contextKey = getContextKey(inlineUnion.context);
+    const typeName = generateAutoTypeName(inlineUnion.context);
+    unionTypeNames.set(contextKey, typeName);
+  }
+
+  return unionTypeNames;
+}
+
+interface ProcessInlineUnionsParams {
+  readonly inlineUnions: ReadonlyArray<InlineUnionWithContext>;
+  readonly knownTypeNames: ReadonlySet<string>;
+  readonly generatedTypeNames: Map<string, string>;
+  readonly enumTypeNames: Map<string, string>;
+  readonly unionTypeNames: Map<string, string>;
+  readonly extractedTypes: ReadonlyArray<ExtractedTypeInfo>;
+}
+
+interface ProcessInlineUnionsResult {
+  readonly types: AutoGeneratedType[];
+  readonly diagnostics: Diagnostic[];
+}
+
+interface ProcessOneOfInputObjectsParams {
+  readonly inlineUnions: ReadonlyArray<InlineUnionWithContext>;
+  readonly knownTypeNames: ReadonlySet<string>;
+  readonly typeMap: ReadonlyMap<string, ExtractedTypeInfo>;
+  readonly unionTypeNames: Map<string, string>;
+}
+
+function processOneOfInputObjects(
+  params: ProcessOneOfInputObjectsParams,
+): ProcessInlineUnionsResult {
+  const { inlineUnions, knownTypeNames, typeMap, unionTypeNames } = params;
+  const types: AutoGeneratedType[] = [];
+  const diagnostics: Diagnostic[] = [];
+
+  for (const inlineUnion of inlineUnions) {
+    const contextKey = getContextKey(inlineUnion.context);
+    const typeName = generateAutoTypeName(inlineUnion.context);
+
+    const validationResult = validateOneOfMembers({
+      members: inlineUnion.members,
+      typeName,
+      sourceLocation: inlineUnion.sourceLocation,
+      typeMap,
+    });
+
+    diagnostics.push(...validationResult.diagnostics);
+
+    if (!validationResult.valid) {
+      continue;
+    }
+
+    const fields = generateOneOfFields({
+      members: inlineUnion.members,
+      knownTypeNames,
+    });
+
+    types.push({
+      name: typeName,
+      kind: "OneOfInputObject",
+      fields,
+      enumValues: null,
+      unionMembers: null,
+      needsStringEnumMapping: false,
+      sourceLocation: inlineUnion.sourceLocation,
+      generatedFrom: buildGeneratedFromInfo(inlineUnion.context),
+      description: null,
+      resolveTypeFieldPattern: null,
+    });
+
+    unionTypeNames.set(contextKey, typeName);
+  }
+
+  return { types, diagnostics };
+}
+
+interface ProcessUnionTypesParams {
+  readonly inlineUnions: ReadonlyArray<InlineUnionWithContext>;
+  readonly knownTypeNames: ReadonlySet<string>;
+  readonly generatedTypeNames: Map<string, string>;
+  readonly enumTypeNames: Map<string, string>;
+  readonly unionTypeNames: Map<string, string>;
+  readonly typeMap: ReadonlyMap<string, ExtractedTypeInfo>;
+}
+
+function processUnionTypes(
+  params: ProcessUnionTypesParams,
+): ProcessInlineUnionsResult {
+  const {
+    inlineUnions,
+    knownTypeNames,
+    generatedTypeNames,
+    enumTypeNames,
+    unionTypeNames,
+    typeMap,
+  } = params;
+  const types: AutoGeneratedType[] = [];
+  const diagnostics: Diagnostic[] = [];
+  const generatedTypenameTypes = new Map<
+    string,
+    ReadonlyArray<AutoGeneratedField>
+  >();
+
+  for (const inlineUnion of inlineUnions) {
+    const contextKey = getContextKey(inlineUnion.context);
+    const typeName = generateAutoTypeName(inlineUnion.context);
+
+    const validationResult = validateUnionMembers({
+      members: inlineUnion.members,
+      typeName,
+      sourceLocation: inlineUnion.sourceLocation,
+      typeMap,
+    });
+
+    diagnostics.push(...validationResult.diagnostics);
+
+    if (!validationResult.valid) {
+      continue;
+    }
+
+    let resolveTypeFieldPattern: AutoGeneratedType["resolveTypeFieldPattern"] =
+      null;
+
+    if (inlineUnion.context.kind === "resolverPayload") {
+      const typenameValidationResult = validateUnionMemberTypenames({
+        members: inlineUnion.members,
+        unionTypeName: typeName,
+        sourceLocation: inlineUnion.sourceLocation,
+        typeMap,
+      });
+
+      diagnostics.push(...typenameValidationResult.diagnostics);
+
+      if (!typenameValidationResult.valid) {
+        continue;
+      }
+
+      if (typenameValidationResult.allMembersHaveTypename) {
+        resolveTypeFieldPattern = determineFieldPattern(
+          typenameValidationResult.memberTypenames,
+        );
+      }
+    }
+
+    const memberNames = resolveMemberNames({
+      members: inlineUnion.members,
+      knownTypeNames,
+      generatedTypeNames,
+      enumTypeNames,
+      parentContext: inlineUnion.context,
+      unionTypeNames,
+      types,
+      diagnostics,
+      generatedTypenameTypes,
+      sourceLocation: inlineUnion.sourceLocation,
+    });
+
+    types.push({
+      name: typeName,
+      kind: "Union",
+      fields: null,
+      enumValues: null,
+      unionMembers: memberNames,
+      needsStringEnumMapping: false,
+      sourceLocation: inlineUnion.sourceLocation,
+      generatedFrom: buildGeneratedFromInfo(inlineUnion.context),
+      description: null,
+      resolveTypeFieldPattern,
+    });
+
+    unionTypeNames.set(contextKey, typeName);
+  }
+
+  return { types, diagnostics };
+}
+
+/**
+ * Determine the field pattern for resolveType based on the typename fields used by members.
+ */
+function determineFieldPattern(
+  memberTypenames: ReadonlyMap<number, ValidatedTypenameInfo>,
+): ResolveTypeFieldPattern {
+  const fieldNames = new Set<TypenameFieldName>();
+  for (const info of memberTypenames.values()) {
+    fieldNames.add(info.fieldName);
+  }
+
+  if (fieldNames.size === 0) {
+    return { usedFieldNames: createFieldNameSet(["__typename"]) };
+  }
+
+  return { usedFieldNames: fieldNames };
+}
+
+function processInlineUnions(
+  params: ProcessInlineUnionsParams,
+): ProcessInlineUnionsResult {
+  const {
+    inlineUnions,
+    knownTypeNames,
+    generatedTypeNames,
+    enumTypeNames,
+    unionTypeNames,
+    extractedTypes,
+  } = params;
+
+  const typeMap = new Map<string, ExtractedTypeInfo>();
+  for (const typeInfo of extractedTypes) {
+    typeMap.set(typeInfo.metadata.name, typeInfo);
+  }
+
+  const inputUnions = inlineUnions.filter((u) => u.isInputContext);
+  const outputUnions = inlineUnions.filter((u) => !u.isInputContext);
+
+  const oneOfResult = processOneOfInputObjects({
+    inlineUnions: inputUnions,
+    knownTypeNames,
+    typeMap,
+    unionTypeNames,
+  });
+
+  const unionResult = processUnionTypes({
+    inlineUnions: outputUnions,
+    knownTypeNames,
+    generatedTypeNames,
+    enumTypeNames,
+    unionTypeNames,
+    typeMap,
+  });
+
+  return {
+    types: [...oneOfResult.types, ...unionResult.types],
+    diagnostics: [...oneOfResult.diagnostics, ...unionResult.diagnostics],
+  };
+}
+
+interface GenerateOneOfFieldsParams {
+  readonly members: ReadonlyArray<InlineUnionMemberInfo>;
+  readonly knownTypeNames: ReadonlySet<string>;
+}
+
+function generateOneOfFields(
+  params: GenerateOneOfFieldsParams,
+): AutoGeneratedField[] {
+  const { members, knownTypeNames } = params;
+
+  const fields: AutoGeneratedField[] = [];
+
+  for (const member of members) {
+    const memberType = member.memberType;
+
+    if (
+      memberType.kind === "inlineObject" &&
+      memberType.inlineObjectProperties
+    ) {
+      for (const prop of memberType.inlineObjectProperties) {
+        const fieldType = convertTsTypeToGraphQLType(
+          prop.tsType,
+          prop.optional,
+        );
+        fields.push({
+          name: prop.name,
+          type: {
+            ...fieldType,
+            nullable: true,
+          },
+          description: prop.description,
+          deprecated: prop.deprecated,
+          directives: prop.directives,
+          defaultValue: prop.defaultValue,
+        });
+      }
+    } else if (memberType.kind === "reference" && memberType.name) {
+      if (knownTypeNames.has(memberType.name)) {
+        const camelCaseName =
+          memberType.name.charAt(0).toLowerCase() + memberType.name.slice(1);
+        fields.push({
+          name: camelCaseName,
+          type: {
+            typeName: memberType.name,
+            nullable: true,
+            list: false,
+            listItemNullable: null,
+          },
+          description: null,
+          deprecated: null,
+          directives: null,
+          defaultValue: null,
+        });
+      }
+    }
+  }
+
+  return fields;
+}
+
+interface ResolveMemberNamesParams {
+  readonly members: ReadonlyArray<InlineUnionMemberInfo>;
+  readonly knownTypeNames: ReadonlySet<string>;
+  readonly generatedTypeNames: Map<string, string>;
+  readonly enumTypeNames: Map<string, string>;
+  readonly parentContext: AutoTypeNameContext;
+  readonly unionTypeNames: Map<string, string>;
+  readonly types: AutoGeneratedType[];
+  readonly diagnostics: Diagnostic[];
+  readonly generatedTypenameTypes: Map<
+    string,
+    ReadonlyArray<AutoGeneratedField>
+  >;
+  readonly sourceLocation: SourceLocation;
+}
+
+/**
+ * Extract __typename or $typeName property value from inline object properties.
+ * Returns null if neither is found or neither is a valid string literal.
+ * __typename takes priority over $typeName if both are present.
+ */
+function extractTypenameFromInlineObject(
+  properties: ReadonlyArray<InlineObjectPropertyDef>,
+): TypenameFieldInfo | null {
+  const found = findTypenameProperty(properties, (p) => p.name);
+  if (!found) {
+    return null;
+  }
+
+  const { property, fieldName } = found;
+  const { tsType } = property;
+
+  if (tsType.kind === "literal" && tsType.name !== null) {
+    return { typeName: tsType.name, fieldName };
+  }
+
+  return null;
+}
+
+function resolveMemberNames(params: ResolveMemberNamesParams): string[] {
+  const {
+    members,
+    generatedTypeNames,
+    parentContext,
+    types,
+    generatedTypenameTypes,
+    diagnostics,
+    sourceLocation,
+  } = params;
+
+  const memberNames: string[] = [];
+
+  for (let i = 0; i < members.length; i++) {
+    const member = members[i]!;
+    const memberType = member.memberType;
+
+    if (memberType.kind === "reference" && memberType.name) {
+      memberNames.push(memberType.name);
+    } else if (
+      memberType.kind === "inlineObject" &&
+      memberType.inlineObjectProperties
+    ) {
+      // Only extract __typename or $typeName for resolverPayload context
+      // For other contexts (resolverArg, objectField, inputField), these fields
+      // should be treated as regular fields, not as type discriminators
+      const extractedInfo =
+        parentContext.kind === "resolverPayload"
+          ? extractTypenameFromInlineObject(memberType.inlineObjectProperties)
+          : null;
+
+      let memberTypeName: string;
+      let contextKey: string;
+
+      if (extractedInfo !== null) {
+        memberTypeName = extractedInfo.typeName;
+        const nestedContext: AutoTypeNameContext = {
+          ...parentContext,
+          fieldPath: [...parentContext.fieldPath, extractedInfo.typeName],
+        };
+        contextKey = getContextKey(nestedContext);
+      } else {
+        const nestedContext: AutoTypeNameContext = {
+          ...parentContext,
+          fieldPath: [...parentContext.fieldPath, `member${i}`],
+        };
+        memberTypeName = generateAutoTypeName(nestedContext);
+        contextKey = getContextKey(nestedContext);
+      }
+
+      // Only filter out __typename or $typeName for resolverPayload context
+      // For other contexts, these are regular fields that should be preserved
+      const typenameFieldToFilter = extractedInfo?.fieldName ?? null;
+      const fields: AutoGeneratedField[] = memberType.inlineObjectProperties
+        .filter(
+          (prop) =>
+            parentContext.kind !== "resolverPayload" ||
+            prop.name !== typenameFieldToFilter,
+        )
+        .map((prop) => {
+          const fieldType = convertTsTypeToGraphQLType(
+            prop.tsType,
+            prop.optional,
+          );
+          return {
+            name: prop.name,
+            type: fieldType,
+            description: prop.description,
+            deprecated: prop.deprecated,
+            directives: prop.directives,
+            defaultValue: prop.defaultValue,
+          };
+        });
+
+      // Check if this typename was already seen with a different field structure
+      if (extractedInfo !== null) {
+        const existingFields = generatedTypenameTypes.get(
+          extractedInfo.typeName,
+        );
+        if (existingFields !== undefined) {
+          // Compare field structures
+          if (!areFieldStructuresEqual(existingFields, fields)) {
+            diagnostics.push({
+              code: "TYPENAME_FIELD_STRUCTURE_MISMATCH",
+              message: `Type with ${extractedInfo.fieldName} '${extractedInfo.typeName}' has inconsistent field structures across different union members. All types with the same ${extractedInfo.fieldName} must have identical field definitions.`,
+              severity: "error",
+              location: sourceLocation,
+            });
+          }
+          // Skip generating duplicate type and avoid adding duplicate union member
+          if (!memberNames.includes(memberTypeName)) {
+            memberNames.push(memberTypeName);
+          }
+          continue;
+        }
+      }
+
+      const nestedContext: AutoTypeNameContext = {
+        ...parentContext,
+        fieldPath: [
+          ...parentContext.fieldPath,
+          extractedInfo?.typeName ?? `member${i}`,
+        ],
+      };
+
+      types.push({
+        name: memberTypeName,
+        kind: "Object",
+        fields,
+        enumValues: null,
+        unionMembers: null,
+        needsStringEnumMapping: false,
+        sourceLocation: {
+          file: "",
+          line: 1,
+          column: 1,
+        },
+        generatedFrom: buildGeneratedFromInfo(nestedContext),
+        description: memberType.inlineObjectDescription,
+        resolveTypeFieldPattern: null,
+      });
+
+      generatedTypeNames.set(contextKey, memberTypeName);
+      if (extractedInfo !== null) {
+        generatedTypenameTypes.set(extractedInfo.typeName, fields);
+      }
+      memberNames.push(memberTypeName);
+    }
+  }
+
+  return memberNames;
+}
+
+/**
+ * Compare two field structures for equality.
+ * Returns true if both have the same fields with the same types.
+ */
+function areFieldStructuresEqual(
+  fields1: ReadonlyArray<AutoGeneratedField>,
+  fields2: ReadonlyArray<AutoGeneratedField>,
+): boolean {
+  if (fields1.length !== fields2.length) {
+    return false;
+  }
+
+  const sorted1 = [...fields1].sort((a, b) => a.name.localeCompare(b.name));
+  const sorted2 = [...fields2].sort((a, b) => a.name.localeCompare(b.name));
+
+  for (let i = 0; i < sorted1.length; i++) {
+    const f1 = sorted1[i]!;
+    const f2 = sorted2[i]!;
+
+    if (f1.name !== f2.name) {
+      return false;
+    }
+
+    if (!areGraphQLTypesEqual(f1.type, f2.type)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Compare two GraphQL type references for equality.
+ */
+function areGraphQLTypesEqual(
+  type1: GraphQLFieldType,
+  type2: GraphQLFieldType,
+): boolean {
+  if (type1.typeName !== type2.typeName) {
+    return false;
+  }
+  if (type1.nullable !== type2.nullable) {
+    return false;
+  }
+  if (type1.list !== type2.list) {
+    return false;
+  }
+  if (type1.listItemNullable !== type2.listItemNullable) {
+    return false;
+  }
+  return true;
+}
+
+export function generateAutoTypes(
+  input: AutoTypeGeneratorInput,
+): AutoTypeGeneratorResult {
+  const inlineObjectsFromTypes: InlineObjectWithContext[] = [];
+  for (const typeInfo of input.extractedTypes) {
+    inlineObjectsFromTypes.push(...collectInlineObjectsFromType(typeInfo));
+  }
+
+  const inlineObjectsFromResolvers = collectInlineObjectsFromResolvers(
+    input.resolversResult,
+  );
+
+  const inlinePayloadsFromResolvers = collectInlinePayloadsFromResolvers(
+    input.resolversResult,
+  );
+
+  const allInlineObjects = [
+    ...inlineObjectsFromTypes,
+    ...inlineObjectsFromResolvers,
+    ...inlinePayloadsFromResolvers,
+  ];
+
+  const generatedTypeNames = buildGeneratedTypeNamesMap(allInlineObjects);
+
+  const inlineEnumsFromTypes = collectInlineEnumsFromTypes(
+    input.extractedTypes,
+  );
+  const inlineEnumsFromResolvers = collectInlineEnumsFromResolvers({
+    resolversResult: input.resolversResult,
+  });
+  const inlineEnumsFromPayloads = collectInlineEnumsFromPayloads({
+    resolversResult: input.resolversResult,
+  });
+  const allInlineEnums = [
+    ...inlineEnumsFromTypes,
+    ...inlineEnumsFromResolvers,
+    ...inlineEnumsFromPayloads,
+  ];
+
+  const { enumTypeNames, uniqueInlineEnums } =
+    buildEnumTypeNamesMap(allInlineEnums);
+
+  // Collect inline unions from types, resolvers, and payloads
+  const inlineUnionsFromTypes = collectInlineUnionsFromTypes({
+    extractedTypes: input.extractedTypes,
+    knownTypeNames: input.knownTypeNames,
+  });
+  const inlineUnionsFromResolvers = collectInlineUnionsFromResolvers({
+    resolversResult: input.resolversResult,
+    knownTypeNames: input.knownTypeNames,
+  });
+  const inlineUnionsFromPayloads = collectInlineUnionsFromPayloads({
+    resolversResult: input.resolversResult,
+    knownTypeNames: input.knownTypeNames,
+  });
+  const allInlineUnions = [
+    ...inlineUnionsFromTypes,
+    ...inlineUnionsFromResolvers,
+    ...inlineUnionsFromPayloads,
+  ];
+
+  // Build union type names map before generating auto types
+  const unionTypeNames = buildUnionTypeNamesMap(allInlineUnions);
+
+  const autoGeneratedTypes: AutoGeneratedType[] = [];
+  const diagnostics: Diagnostic[] = [];
+
+  for (const inlineObj of allInlineObjects) {
+    const result = generateAutoType({
+      inlineObj,
+      generatedTypeNames,
+      enumTypeNames,
+      unionTypeNames,
+    });
+    autoGeneratedTypes.push(result.type);
+    diagnostics.push(...result.diagnostics);
+  }
+
+  for (const inlineEnum of uniqueInlineEnums) {
+    const contextKey = getContextKey(inlineEnum.context);
+    const typeName = enumTypeNames.get(contextKey)!;
+    const result = generateAutoEnumType(inlineEnum, typeName);
+    autoGeneratedTypes.push(result.type);
+    diagnostics.push(...result.diagnostics);
+  }
+
+  // Process inline unions
+  const { types: unionTypes, diagnostics: unionDiagnostics } =
+    processInlineUnions({
+      inlineUnions: allInlineUnions,
+      knownTypeNames: input.knownTypeNames,
+      generatedTypeNames,
+      enumTypeNames,
+      unionTypeNames,
+      extractedTypes: input.extractedTypes,
+    });
+  autoGeneratedTypes.push(...unionTypes);
+  diagnostics.push(...unionDiagnostics);
+
+  const updateParams: UpdateTypeNamesParams = {
+    generatedTypeNames,
+    enumTypeNames,
+    unionTypeNames,
+  };
+
+  const updatedExtractedTypes = updateExtractedTypes(
+    input.extractedTypes,
+    updateParams,
+  );
+
+  const updatedResolversResult = updateResolversResult(
+    input.resolversResult,
+    updateParams,
+  );
+
+  return {
+    autoGeneratedTypes,
+    updatedExtractedTypes,
+    updatedResolversResult,
+    diagnostics,
+  };
+}