@gqlkit-ts/cli 0.6.0 → 0.7.1

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

@@ -1,4 +1,5 @@
 import type ts from "typescript";
+import type { ResolvedDiscriminatorFieldsMap } from "../config-loader/index.js";
 import type {
   ExtractResolversResult,
   GraphQLFieldDefinition,
@@ -25,6 +26,7 @@ import {
   type InlineEnumMemberInfo,
   type InlineObjectPropertyDef,
   type SourceLocation,
+  type TSTypeReference,
 } from "../type-extractor/types/index.js";
 import {
   collectInlineEnumsFromPayloads,
@@ -45,8 +47,13 @@ import {
   validateUnionMembers,
   validateUnionMemberTypenames,
 } from "./inline-union-validator.js";
+import {
+  flattenInlineUnionMembers,
+  type InlineDiscriminatorResolveType,
+} from "./intersection-flattener.js";
 import {
   type AutoTypeNameContext,
+  appendFieldPath,
   buildFieldContext,
   generateAutoTypeName,
   isInputTypeName,
@@ -59,6 +66,7 @@ import {
 import {
   createFieldNameSet,
   findTypenameProperty,
+  isTypenameFieldName,
   type TypenameFieldInfo,
   type TypenameFieldName,
 } from "./typename-types.js";
@@ -130,6 +138,7 @@ export interface AutoTypeGeneratorInput {
   readonly extractedTypes: ReadonlyArray<ExtractedTypeInfo>;
   readonly resolversResult: ExtractResolversResult;
   readonly knownTypeNames: ReadonlySet<string>;
+  readonly discriminatorFields: ResolvedDiscriminatorFieldsMap;
 }
 
 export interface AutoTypeGeneratorResult {
@@ -137,6 +146,10 @@ export interface AutoTypeGeneratorResult {
   readonly updatedExtractedTypes: ReadonlyArray<ExtractedTypeInfo>;
   readonly updatedResolversResult: ExtractResolversResult;
   readonly diagnostics: ReadonlyArray<Diagnostic>;
+  /** Mapping from TypeScript type alias names to auto-generated GraphQL union names */
+  readonly tsAliasToGraphQLNameMap: ReadonlyMap<string, string>;
+  /** Discriminator resolveType info for inline unions that were flattened by discriminator fields */
+  readonly inlineDiscriminatorResolveTypes: ReadonlyArray<InlineDiscriminatorResolveType>;
 }
 
 interface InlineObjectWithContext {
@@ -163,6 +176,41 @@ interface ExtractNestedInlineObjectsParams {
   readonly results: InlineObjectWithContext[];
 }
 
+interface InlineObjectTypeInfo {
+  readonly properties: ReadonlyArray<InlineObjectPropertyDef>;
+  readonly nullable: boolean;
+  readonly description: string | null;
+  readonly deprecated: DeprecationInfo | null;
+}
+
+function getInlineObjectTypeInfo(
+  tsType: TSTypeReference,
+): InlineObjectTypeInfo | null {
+  if (tsType.kind === "inlineObject" && tsType.inlineObjectProperties) {
+    return {
+      properties: tsType.inlineObjectProperties,
+      nullable: tsType.nullable,
+      description: tsType.inlineObjectDescription,
+      deprecated: tsType.inlineObjectDeprecated,
+    };
+  }
+
+  if (
+    tsType.kind === "array" &&
+    tsType.elementType?.kind === "inlineObject" &&
+    tsType.elementType.inlineObjectProperties
+  ) {
+    return {
+      properties: tsType.elementType.inlineObjectProperties,
+      nullable: tsType.elementType.nullable,
+      description: tsType.elementType.inlineObjectDescription,
+      deprecated: tsType.elementType.inlineObjectDeprecated,
+    };
+  }
+
+  return null;
+}
+
 function extractNestedInlineObjectsRecursively(
   params: ExtractNestedInlineObjectsParams,
 ): void {
@@ -174,32 +222,37 @@ function extractNestedInlineObjectsRecursively(
     preserveDocumentation,
     results,
   } = params;
+  const siblingFieldNames = new Set(properties.map((prop) => prop.name));
 
   for (const prop of properties) {
-    if (
-      prop.tsType.kind === "inlineObject" &&
-      prop.tsType.inlineObjectProperties
-    ) {
-      const nestedPath = [...currentPath, prop.name];
+    const inlineObjectTypeInfo = getInlineObjectTypeInfo(prop.tsType);
+
+    if (inlineObjectTypeInfo) {
+      const nestedPath = appendFieldPath({
+        parentPath: currentPath,
+        fieldName: prop.name,
+        singularize: prop.tsType.kind === "array",
+        siblingFieldNames,
+      });
       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,
+        properties: inlineObjectTypeInfo.properties,
         context: nestedContext,
         sourceLocation: nestedSourceLocation,
-        nullable: prop.tsType.nullable,
+        nullable: inlineObjectTypeInfo.nullable,
         description: preserveDocumentation
-          ? prop.tsType.inlineObjectDescription
+          ? inlineObjectTypeInfo.description
           : null,
         deprecated: preserveDocumentation
-          ? prop.tsType.inlineObjectDeprecated
+          ? inlineObjectTypeInfo.deprecated
           : null,
       });
 
       extractNestedInlineObjectsRecursively({
-        properties: prop.tsType.inlineObjectProperties,
+        properties: inlineObjectTypeInfo.properties,
         currentPath: nestedPath,
         sourceLocation: nestedSourceLocation,
         buildContext,
@@ -258,6 +311,7 @@ function collectInlineObjectsFromType(
 ): InlineObjectWithContext[] {
   const results: InlineObjectWithContext[] = [];
   const isInput = isInputTypeName(typeInfo.metadata.name);
+  const siblingFieldNames = new Set(typeInfo.fields.map((field) => field.name));
 
   for (const field of typeInfo.fields) {
     collectInlineObjectsFromField({
@@ -266,6 +320,7 @@ function collectInlineObjectsFromType(
       parentPath: [],
       isInput,
       sourceFile: typeInfo.metadata.sourceFile,
+      siblingFieldNames,
       results,
     });
   }
@@ -279,21 +334,34 @@ interface CollectInlineObjectsFromFieldParams {
   readonly parentPath: ReadonlyArray<string>;
   readonly isInput: boolean;
   readonly sourceFile: string;
+  readonly siblingFieldNames: ReadonlySet<string>;
   readonly results: InlineObjectWithContext[];
 }
 
 function collectInlineObjectsFromField(
   params: CollectInlineObjectsFromFieldParams,
 ): void {
-  const { field, parentTypeName, parentPath, isInput, sourceFile, results } =
-    params;
-  const tsType = field.tsType;
+  const {
+    field,
+    parentTypeName,
+    parentPath,
+    isInput,
+    sourceFile,
+    siblingFieldNames,
+    results,
+  } = params;
+  const inlineObjectTypeInfo = getInlineObjectTypeInfo(field.tsType);
 
-  if (tsType.kind !== "inlineObject" || !tsType.inlineObjectProperties) {
+  if (!inlineObjectTypeInfo) {
     return;
   }
 
-  const fieldPath = [...parentPath, field.name];
+  const fieldPath = appendFieldPath({
+    parentPath,
+    fieldName: field.name,
+    singularize: field.tsType.kind === "array",
+    siblingFieldNames,
+  });
 
   const context: AutoTypeNameContext = isInput
     ? {
@@ -313,16 +381,16 @@ function collectInlineObjectsFromField(
   );
 
   results.push({
-    properties: tsType.inlineObjectProperties,
+    properties: inlineObjectTypeInfo.properties,
     context,
     sourceLocation,
-    nullable: tsType.nullable,
-    description: tsType.inlineObjectDescription,
-    deprecated: tsType.inlineObjectDeprecated,
+    nullable: inlineObjectTypeInfo.nullable,
+    description: inlineObjectTypeInfo.description,
+    deprecated: inlineObjectTypeInfo.deprecated,
   });
 
   extractNestedInlineObjectsRecursively({
-    properties: tsType.inlineObjectProperties,
+    properties: inlineObjectTypeInfo.properties,
     currentPath: fieldPath,
     sourceLocation,
     buildContext: (nestedPath) =>
@@ -486,8 +554,16 @@ function generateAutoType(
 
   const fields: AutoGeneratedField[] = [];
   const diagnostics: Diagnostic[] = [];
+  const siblingFieldNames = new Set(
+    inlineObj.properties.map((prop) => prop.name),
+  );
 
   for (const prop of inlineObj.properties) {
+    // Typename discrimination fields are silently excluded from the schema
+    if (isTypenameFieldName(prop.name)) {
+      continue;
+    }
+
     const eligibility = isEligibleField({
       fieldName: prop.name,
       kind: isInput ? "input" : "object",
@@ -509,7 +585,14 @@ function generateAutoType(
       enumTypeNames,
       unionTypeNames,
       parentContext: inlineObj.context,
+      siblingFieldNames,
     });
+
+    // Skip fields with never type — they represent impossible values
+    if (fieldType.typeName === "__NEVER__") {
+      continue;
+    }
+
     fields.push({
       name: prop.name,
       type: fieldType,
@@ -543,14 +626,21 @@ interface ResolveFieldTypeParams {
   readonly enumTypeNames: Map<string, string>;
   readonly unionTypeNames: Map<string, string>;
   readonly parentContext: AutoTypeNameContext;
+  readonly siblingFieldNames: ReadonlySet<string>;
 }
 
 function tryResolveNestedType(
   prop: InlineObjectPropertyDef,
   parentContext: AutoTypeNameContext,
   typeNamesMap: ReadonlyMap<string, string>,
+  siblingFieldNames: ReadonlySet<string>,
 ): GraphQLFieldType | null {
-  const nestedPath = [...parentContext.fieldPath, prop.name];
+  const nestedPath = appendFieldPath({
+    parentPath: parentContext.fieldPath,
+    fieldName: prop.name,
+    singularize: prop.tsType.kind === "array",
+    siblingFieldNames,
+  });
   const nestedContext: AutoTypeNameContext = {
     ...parentContext,
     fieldPath: nestedPath,
@@ -560,10 +650,8 @@ function tryResolveNestedType(
 
   if (resolvedTypeName) {
     return {
+      ...convertTsTypeToGraphQLType(prop.tsType, prop.optional),
       typeName: resolvedTypeName,
-      nullable: prop.tsType.nullable || prop.optional,
-      list: false,
-      listItemNullable: null,
     };
   }
   return null;
@@ -576,27 +664,52 @@ function resolveFieldType(params: ResolveFieldTypeParams): GraphQLFieldType {
     enumTypeNames,
     unionTypeNames,
     parentContext,
+    siblingFieldNames,
   } = params;
 
   if (
-    prop.tsType.kind === "inlineObject" &&
-    prop.tsType.inlineObjectProperties
+    (prop.tsType.kind === "inlineObject" &&
+      prop.tsType.inlineObjectProperties) ||
+    (prop.tsType.kind === "array" &&
+      prop.tsType.elementType?.kind === "inlineObject" &&
+      prop.tsType.elementType.inlineObjectProperties)
   ) {
     const result = tryResolveNestedType(
       prop,
       parentContext,
       generatedTypeNames,
+      siblingFieldNames,
     );
     if (result) return result;
   }
 
-  if (prop.tsType.kind === "inlineEnum" && prop.tsType.inlineEnumMembers) {
-    const result = tryResolveNestedType(prop, parentContext, enumTypeNames);
+  if (
+    (prop.tsType.kind === "inlineEnum" && prop.tsType.inlineEnumMembers) ||
+    (prop.tsType.kind === "array" &&
+      prop.tsType.elementType?.kind === "inlineEnum" &&
+      prop.tsType.elementType.inlineEnumMembers)
+  ) {
+    const result = tryResolveNestedType(
+      prop,
+      parentContext,
+      enumTypeNames,
+      siblingFieldNames,
+    );
     if (result) return result;
   }
 
-  if (prop.tsType.kind === "union" && prop.tsType.members) {
-    const result = tryResolveNestedType(prop, parentContext, unionTypeNames);
+  if (
+    (prop.tsType.kind === "union" && prop.tsType.members) ||
+    (prop.tsType.kind === "array" &&
+      prop.tsType.elementType?.kind === "union" &&
+      prop.tsType.elementType.members)
+  ) {
+    const result = tryResolveNestedType(
+      prop,
+      parentContext,
+      unionTypeNames,
+      siblingFieldNames,
+    );
     if (result) return result;
   }
 
@@ -615,10 +728,19 @@ function updateExtractedTypes(
 ): ExtractedTypeInfo[] {
   return extractedTypes.map((typeInfo) => {
     const isInput = isInputTypeName(typeInfo.metadata.name);
+    const siblingFieldNames = new Set(
+      typeInfo.fields.map((field) => field.name),
+    );
     return {
       ...typeInfo,
       fields: typeInfo.fields.map((field) =>
-        updateField(field, params, typeInfo.metadata.name, isInput),
+        updateField(
+          field,
+          params,
+          typeInfo.metadata.name,
+          isInput,
+          siblingFieldNames,
+        ),
       ),
     };
   });
@@ -629,9 +751,19 @@ function updateField(
   params: UpdateTypeNamesParams,
   parentTypeName: string,
   isInput: boolean,
+  siblingFieldNames: ReadonlySet<string>,
 ): FieldDefinition {
   const { generatedTypeNames, enumTypeNames, unionTypeNames } = params;
-  const context = buildFieldContext(parentTypeName, [field.name], isInput);
+  const context = buildFieldContext(
+    parentTypeName,
+    appendFieldPath({
+      parentPath: [],
+      fieldName: field.name,
+      singularize: field.tsType.kind === "array",
+      siblingFieldNames,
+    }),
+    isInput,
+  );
   const contextKey = getContextKey(context);
 
   // Handle inline objects
@@ -651,6 +783,27 @@ function updateField(
     }
   }
 
+  // Handle array of inline objects
+  if (
+    field.tsType.kind === "array" &&
+    field.tsType.elementType?.kind === "inlineObject" &&
+    field.tsType.elementType.inlineObjectProperties
+  ) {
+    const resolvedTypeName = generatedTypeNames.get(contextKey);
+    if (resolvedTypeName) {
+      return {
+        ...field,
+        tsType: {
+          ...field.tsType,
+          elementType: createReferenceType({
+            name: resolvedTypeName,
+            nullable: field.tsType.elementType.nullable,
+          }),
+        },
+      };
+    }
+  }
+
   // Handle inline enums
   if (field.tsType.kind === "inlineEnum" && field.tsType.inlineEnumMembers) {
     const resolvedTypeName = enumTypeNames.get(contextKey);
@@ -700,6 +853,27 @@ function updateField(
     }
   }
 
+  // Handle array of inline union types
+  if (
+    field.tsType.kind === "array" &&
+    field.tsType.elementType?.kind === "union" &&
+    field.tsType.elementType.members
+  ) {
+    const resolvedTypeName = unionTypeNames.get(contextKey);
+    if (resolvedTypeName) {
+      return {
+        ...field,
+        tsType: {
+          ...field.tsType,
+          elementType: createReferenceType({
+            name: resolvedTypeName,
+            nullable: field.tsType.elementType.nullable,
+          }),
+        },
+      };
+    }
+  }
+
   return field;
 }
 
@@ -1290,6 +1464,9 @@ function generateOneOfFields(
           prop.tsType,
           prop.optional,
         );
+        if (fieldType.typeName === "__NEVER__") {
+          continue;
+        }
         fields.push({
           name: prop.name,
           type: {
@@ -1358,13 +1535,306 @@ function extractTypenameFromInlineObject(
   const { property, fieldName } = found;
   const { tsType } = property;
 
-  if (tsType.kind === "literal" && tsType.name !== null) {
+  if (tsType.kind === "stringLiteral" && tsType.name !== null) {
     return { typeName: tsType.name, fieldName };
   }
 
   return null;
 }
 
+/**
+ * Shared parameters for resolving inline types within union member properties.
+ */
+interface MemberFieldResolutionContext {
+  readonly types: AutoGeneratedType[];
+  readonly generatedTypeNames: Map<string, string>;
+  readonly diagnostics: Diagnostic[];
+  readonly sourceLocation: SourceLocation;
+  readonly knownTypeNames: ReadonlySet<string>;
+}
+
+/**
+ * Convert inline object/enum/union properties within a union member to AutoGeneratedFields.
+ * Handles __INLINE_OBJECT__, __INLINE_ENUM__, and inline union (kind: "union") sentinels
+ * by generating appropriate auto types and replacing sentinel type names.
+ */
+function convertMemberPropertiesToFields(
+  properties: ReadonlyArray<InlineObjectPropertyDef>,
+  parentTypeName: string,
+  ctx: MemberFieldResolutionContext,
+): AutoGeneratedField[] {
+  const siblingFieldNames = new Set(properties.map((prop) => prop.name));
+  return properties.flatMap((prop) => {
+    const fieldType = convertTsTypeToGraphQLType(prop.tsType, prop.optional);
+    if (fieldType.typeName === "__NEVER__") {
+      return [];
+    }
+
+    const resolvedTypeName = resolveInlineTypeInMember(
+      prop,
+      fieldType,
+      parentTypeName,
+      siblingFieldNames,
+      ctx,
+    );
+
+    return {
+      name: prop.name,
+      type: resolvedTypeName
+        ? { ...fieldType, typeName: resolvedTypeName }
+        : fieldType,
+      description: prop.description,
+      deprecated: prop.deprecated,
+      directives: prop.directives,
+      defaultValue: prop.defaultValue,
+    };
+  });
+}
+
+/**
+ * Resolve an inline type (object, enum, or union) within a union member property.
+ * Returns the generated type name if resolved, or null if no resolution is needed.
+ */
+function resolveInlineTypeInMember(
+  prop: InlineObjectPropertyDef,
+  fieldType: GraphQLFieldType,
+  parentTypeName: string,
+  siblingFieldNames: ReadonlySet<string>,
+  ctx: MemberFieldResolutionContext,
+): string | null {
+  // Determine the inline TS type (direct or array element)
+  const inlineTsType =
+    prop.tsType.kind === "array" ? prop.tsType.elementType : prop.tsType;
+  const singularizeArrayFieldName = prop.tsType.kind === "array";
+  if (!inlineTsType) return null;
+
+  // Resolve nested inline objects
+  if (
+    fieldType.typeName === "__INLINE_OBJECT__" &&
+    inlineTsType.kind === "inlineObject" &&
+    inlineTsType.inlineObjectProperties
+  ) {
+    return resolveNestedInlineObjectInMember(
+      inlineTsType.inlineObjectProperties,
+      prop.name,
+      singularizeArrayFieldName,
+      parentTypeName,
+      siblingFieldNames,
+      ctx,
+      inlineTsType.inlineObjectDescription,
+    );
+  }
+
+  // Resolve inline enums (string literal unions)
+  if (
+    fieldType.typeName === "__INLINE_ENUM__" &&
+    inlineTsType.kind === "inlineEnum" &&
+    inlineTsType.inlineEnumMembers
+  ) {
+    return resolveInlineEnumInMember(
+      inlineTsType.inlineEnumMembers,
+      prop.name,
+      singularizeArrayFieldName,
+      parentTypeName,
+      siblingFieldNames,
+      ctx,
+      inlineTsType.externalEnumDescription,
+    );
+  }
+
+  // Resolve inline unions (reference type unions like User | Bot)
+  if (inlineTsType.kind === "union" && inlineTsType.members) {
+    return resolveInlineUnionInMember(
+      inlineTsType.members,
+      prop.name,
+      singularizeArrayFieldName,
+      parentTypeName,
+      siblingFieldNames,
+      ctx,
+    );
+  }
+
+  return null;
+}
+
+/**
+ * Resolve a nested inline object within an inline union member.
+ * Generates an AutoGeneratedType using objectField context and recurses
+ * into deeper nesting levels.
+ */
+function resolveNestedInlineObjectInMember(
+  properties: ReadonlyArray<InlineObjectPropertyDef>,
+  fieldName: string,
+  singularizeArrayFieldName: boolean,
+  parentTypeName: string,
+  siblingFieldNames: ReadonlySet<string>,
+  ctx: MemberFieldResolutionContext,
+  description: string | null,
+): string {
+  const context: AutoTypeNameContext = {
+    kind: "objectField",
+    parentTypeName,
+    fieldPath: appendFieldPath({
+      parentPath: [],
+      fieldName,
+      singularize: singularizeArrayFieldName,
+      siblingFieldNames,
+    }),
+  };
+  const typeName = generateAutoTypeName(context);
+  const contextKey = getContextKey(context);
+
+  if (ctx.generatedTypeNames.has(contextKey)) {
+    return ctx.generatedTypeNames.get(contextKey)!;
+  }
+
+  const fields = convertMemberPropertiesToFields(properties, typeName, ctx);
+
+  ctx.types.push({
+    name: typeName,
+    kind: "Object",
+    fields,
+    enumValues: null,
+    unionMembers: null,
+    needsStringEnumMapping: false,
+    sourceLocation: ctx.sourceLocation,
+    generatedFrom: buildGeneratedFromInfo(context),
+    description,
+    resolveTypeFieldPattern: null,
+  });
+
+  ctx.generatedTypeNames.set(contextKey, typeName);
+
+  return typeName;
+}
+
+/**
+ * Resolve an inline enum (string literal union) within an inline union member.
+ */
+function resolveInlineEnumInMember(
+  members: ReadonlyArray<InlineEnumMemberInfo>,
+  fieldName: string,
+  singularizeArrayFieldName: boolean,
+  parentTypeName: string,
+  siblingFieldNames: ReadonlySet<string>,
+  ctx: MemberFieldResolutionContext,
+  description: string | null,
+): string {
+  const context: AutoTypeNameContext = {
+    kind: "objectField",
+    parentTypeName,
+    fieldPath: appendFieldPath({
+      parentPath: [],
+      fieldName,
+      singularize: singularizeArrayFieldName,
+      siblingFieldNames,
+    }),
+  };
+  const typeName = generateAutoTypeName(context);
+  const contextKey = getContextKey(context);
+
+  if (ctx.generatedTypeNames.has(contextKey)) {
+    return ctx.generatedTypeNames.get(contextKey)!;
+  }
+
+  const {
+    enumValues,
+    needsStringEnumMapping,
+    diagnostics: enumDiagnostics,
+  } = convertInlineEnumMembers({
+    members,
+    enumName: typeName,
+    sourceLocation: ctx.sourceLocation,
+  });
+
+  ctx.diagnostics.push(...enumDiagnostics);
+
+  ctx.types.push({
+    name: typeName,
+    kind: "Enum",
+    fields: null,
+    enumValues,
+    unionMembers: null,
+    needsStringEnumMapping,
+    sourceLocation: ctx.sourceLocation,
+    generatedFrom: buildGeneratedFromInfo(context),
+    description,
+    resolveTypeFieldPattern: null,
+  });
+
+  ctx.generatedTypeNames.set(contextKey, typeName);
+
+  return typeName;
+}
+
+/**
+ * Resolve an inline union of reference types within an inline union member.
+ */
+function resolveInlineUnionInMember(
+  members: ReadonlyArray<TSTypeReference>,
+  fieldName: string,
+  singularizeArrayFieldName: boolean,
+  parentTypeName: string,
+  siblingFieldNames: ReadonlySet<string>,
+  ctx: MemberFieldResolutionContext,
+): string {
+  const context: AutoTypeNameContext = {
+    kind: "objectField",
+    parentTypeName,
+    fieldPath: appendFieldPath({
+      parentPath: [],
+      fieldName,
+      singularize: singularizeArrayFieldName,
+      siblingFieldNames,
+    }),
+  };
+  const typeName = generateAutoTypeName(context);
+  const contextKey = getContextKey(context);
+
+  if (ctx.generatedTypeNames.has(contextKey)) {
+    return ctx.generatedTypeNames.get(contextKey)!;
+  }
+
+  const memberNames: string[] = [];
+  for (const member of members) {
+    if (member.kind === "reference" && member.name) {
+      if (ctx.knownTypeNames.has(member.name)) {
+        memberNames.push(member.name);
+      }
+    }
+  }
+
+  if (memberNames.length === 0) {
+    const memberDescriptions = members
+      .map((m) => m.name ?? "(anonymous)")
+      .join(", ");
+    ctx.diagnostics.push({
+      code: "INLINE_UNION_UNRESOLVABLE_MEMBER",
+      message: `Could not resolve any members of inline union '${typeName}' in '${parentTypeName}.${fieldName}'. None of the member types [${memberDescriptions}] are known schema types.`,
+      severity: "error",
+      location: ctx.sourceLocation,
+    });
+    return typeName;
+  }
+
+  ctx.types.push({
+    name: typeName,
+    kind: "Union",
+    fields: null,
+    enumValues: null,
+    unionMembers: memberNames,
+    needsStringEnumMapping: false,
+    sourceLocation: ctx.sourceLocation,
+    generatedFrom: buildGeneratedFromInfo(context),
+    description: null,
+    resolveTypeFieldPattern: null,
+  });
+
+  ctx.generatedTypeNames.set(contextKey, typeName);
+
+  return typeName;
+}
+
 function resolveMemberNames(params: ResolveMemberNamesParams): string[] {
   const {
     members,
@@ -1406,38 +1876,47 @@ function resolveMemberNames(params: ResolveMemberNamesParams): string[] {
           fieldPath: [...parentContext.fieldPath, extractedInfo.typeName],
         };
         contextKey = getContextKey(nestedContext);
-      } else {
+      } else if (memberType.inlineObjectHintName !== null) {
         const nestedContext: AutoTypeNameContext = {
           ...parentContext,
-          fieldPath: [...parentContext.fieldPath, `member${i}`],
+          fieldPath: [
+            ...parentContext.fieldPath,
+            memberType.inlineObjectHintName,
+          ],
         };
-        memberTypeName = generateAutoTypeName(nestedContext);
+        memberTypeName = memberType.inlineObjectHintName;
         contextKey = getContextKey(nestedContext);
+      } else {
+        diagnostics.push({
+          code: "UNNAMEABLE_UNION_MEMBER",
+          message: `Inline object union member at index ${i} cannot be named. Use a named type (type alias or interface) for each union member, or add a '__typename' property with a string literal type.`,
+          severity: "error",
+          location: sourceLocation,
+        });
+        continue;
       }
 
       // 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,
-          };
-        });
+      const filteredProperties = memberType.inlineObjectProperties.filter(
+        (prop) =>
+          parentContext.kind !== "resolverPayload" ||
+          prop.name !== typenameFieldToFilter,
+      );
+
+      const fieldCtx: MemberFieldResolutionContext = {
+        types,
+        generatedTypeNames,
+        diagnostics,
+        sourceLocation,
+        knownTypeNames: params.knownTypeNames,
+      };
+      const fields = convertMemberPropertiesToFields(
+        filteredProperties,
+        memberTypeName,
+        fieldCtx,
+      );
 
       // Check if this typename was already seen with a different field structure
       if (extractedInfo !== null) {
@@ -1466,7 +1945,7 @@ function resolveMemberNames(params: ResolveMemberNamesParams): string[] {
         ...parentContext,
         fieldPath: [
           ...parentContext.fieldPath,
-          extractedInfo?.typeName ?? `member${i}`,
+          extractedInfo?.typeName ?? memberType.inlineObjectHintName!,
         ],
       };
 
@@ -1606,12 +2085,21 @@ export function generateAutoTypes(
     resolversResult: input.resolversResult,
     knownTypeNames: input.knownTypeNames,
   });
-  const allInlineUnions = [
+  const allInlineUnionsRaw = [
     ...inlineUnionsFromTypes,
     ...inlineUnionsFromResolvers,
     ...inlineUnionsFromPayloads,
   ];
 
+  // Apply discriminator-aware flattening to inline unions before processing.
+  // This resolves the case where TypeScript distributes intersections over unions
+  // within field types, creating many anonymous inline objects.
+  const flattenResult = flattenInlineUnionMembers({
+    inlineUnions: allInlineUnionsRaw,
+    discriminatorFields: input.discriminatorFields,
+  });
+  const allInlineUnions = [...flattenResult.inlineUnions];
+
   // Build union type names map before generating auto types
   const unionTypeNames = buildUnionTypeNamesMap(allInlineUnions);
 
@@ -1666,10 +2154,40 @@ export function generateAutoTypes(
     updateParams,
   );
 
+  // Build mapping from TS type alias names to auto-generated GraphQL union names
+  const tsAliasToGraphQLNameMap = buildTsAliasToGraphQLNameMap(
+    allInlineUnions,
+    unionTypeNames,
+  );
+
   return {
     autoGeneratedTypes,
     updatedExtractedTypes,
     updatedResolversResult,
     diagnostics,
+    tsAliasToGraphQLNameMap,
+    inlineDiscriminatorResolveTypes:
+      flattenResult.inlineDiscriminatorResolveTypes,
   };
 }
+
+function buildTsAliasToGraphQLNameMap(
+  inlineUnions: ReadonlyArray<InlineUnionWithContext>,
+  unionTypeNames: ReadonlyMap<string, string>,
+): ReadonlyMap<string, string> {
+  const result = new Map<string, string>();
+
+  for (const inlineUnion of inlineUnions) {
+    if (inlineUnion.unionAliasName === null) {
+      continue;
+    }
+
+    const contextKey = getContextKey(inlineUnion.context);
+    const generatedName = unionTypeNames.get(contextKey);
+    if (generatedName !== undefined) {
+      result.set(inlineUnion.unionAliasName, generatedName);
+    }
+  }
+
+  return result;
+}