@gqlkit-ts/cli 0.1.0 → 0.3.0

package/dist/auto-type-generator/auto-type-generator.js

@@ -1,8 +1,45 @@
+import { detectEnumPrefix, stripEnumPrefix, } from "../shared/enum-prefix-detector.js";
+import { getSourceLocationOrDefault } from "../shared/source-location.js";
 import { convertTsTypeToGraphQLType } from "../shared/type-converter.js";
 import { isEligibleAsInputObjectField, isEligibleAsObjectField, } from "../type-extractor/converter/field-eligibility.js";
-import { generateAutoTypeName, } from "./naming-convention.js";
-function isInputTypeName(name) {
-    return name.endsWith("Input");
+import { createReferenceType, } from "../type-extractor/types/index.js";
+import { collectInlineEnumsFromPayloads, collectInlineEnumsFromResolvers, collectInlineEnumsFromTypes, } from "./inline-enum-collector.js";
+import { collectInlineUnionsFromPayloads, collectInlineUnionsFromResolvers, collectInlineUnionsFromTypes, } from "./inline-union-collector.js";
+import { validateOneOfMembers, validateUnionMembers, validateUnionMemberTypenames, } from "./inline-union-validator.js";
+import { buildFieldContext, generateAutoTypeName, isInputTypeName, } from "./naming-convention.js";
+import { forEachResolverField } from "./resolver-field-iterator.js";
+import { createFieldNameSet, findTypenameProperty, } from "./typename-types.js";
+function extractNestedInlineObjectsRecursively(params) {
+    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) {
     switch (context.kind) {
@@ -12,8 +49,32 @@ function getContextKey(context) {
             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) {
+    switch (kind) {
+        case "objectField":
+            return "typeField";
+        case "inputField":
+            return "inputField";
+        case "resolverArg":
+            return "resolverArg";
+        case "resolverPayload":
+            return "resolverPayload";
+    }
+}
+function buildGeneratedFromInfo(context) {
+    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) {
     const results = [];
     const isInput = isInputTypeName(typeInfo.metadata.name);
@@ -39,78 +100,31 @@ function collectInlineObjectsFromField(field, parentTypeName, parentPath, isInpu
             parentTypeName,
             fieldPath,
         };
+    const sourceLocation = getSourceLocationOrDefault(field.sourceLocation, sourceFile);
     results.push({
         properties: tsType.inlineObjectProperties,
         context,
-        sourceLocation: field.sourceLocation ?? {
-            file: sourceFile,
-            line: 1,
-            column: 1,
-        },
+        sourceLocation,
         nullable: tsType.nullable,
+        description: tsType.inlineObjectDescription,
+        deprecated: tsType.inlineObjectDeprecated,
     });
-    for (const prop of tsType.inlineObjectProperties) {
-        if (prop.tsType.kind === "inlineObject" &&
-            prop.tsType.inlineObjectProperties) {
-            const nestedPath = [...fieldPath, prop.name];
-            const nestedContext = isInput
-                ? {
-                    kind: "inputField",
-                    parentTypeName,
-                    fieldPath: nestedPath,
-                }
-                : {
-                    kind: "objectField",
-                    parentTypeName,
-                    fieldPath: nestedPath,
-                };
-            extractNestedInlineObjects(prop.tsType.inlineObjectProperties, nestedContext, nestedPath, parentTypeName, isInput, sourceFile, prop.sourceLocation, results);
-        }
-    }
-}
-function extractNestedInlineObjects(properties, context, currentPath, parentTypeName, isInput, sourceFile, parentSourceLocation, results) {
-    results.push({
-        properties,
-        context,
-        sourceLocation: parentSourceLocation ?? {
-            file: sourceFile,
-            line: 1,
-            column: 1,
-        },
-        nullable: false,
+    extractNestedInlineObjectsRecursively({
+        properties: tsType.inlineObjectProperties,
+        currentPath: fieldPath,
+        sourceLocation,
+        buildContext: (nestedPath) => isInput
+            ? { kind: "inputField", parentTypeName, fieldPath: nestedPath }
+            : { kind: "objectField", parentTypeName, fieldPath: nestedPath },
+        preserveDocumentation: true,
+        results,
     });
-    for (const prop of properties) {
-        if (prop.tsType.kind === "inlineObject" &&
-            prop.tsType.inlineObjectProperties) {
-            const nestedPath = [...currentPath, prop.name];
-            const nestedContext = isInput
-                ? {
-                    kind: "inputField",
-                    parentTypeName,
-                    fieldPath: nestedPath,
-                }
-                : {
-                    kind: "objectField",
-                    parentTypeName,
-                    fieldPath: nestedPath,
-                };
-            extractNestedInlineObjects(prop.tsType.inlineObjectProperties, nestedContext, nestedPath, parentTypeName, isInput, sourceFile, prop.sourceLocation, results);
-        }
-    }
 }
 function collectInlineObjectsFromResolvers(resolversResult) {
     const results = [];
-    for (const field of resolversResult.queryFields.fields) {
-        collectInlineObjectsFromResolverArgs(field, "query", null, results);
-    }
-    for (const field of resolversResult.mutationFields.fields) {
-        collectInlineObjectsFromResolverArgs(field, "mutation", null, results);
-    }
-    for (const ext of resolversResult.typeExtensions) {
-        for (const field of ext.fields) {
-            collectInlineObjectsFromResolverArgs(field, "field", ext.targetTypeName, results);
-        }
-    }
+    forEachResolverField(resolversResult, ({ field, resolverType, parentTypeName }) => {
+        collectInlineObjectsFromResolverArgs(field, resolverType, parentTypeName, results);
+    });
     return results;
 }
 function collectInlineObjectsFromResolverArgs(field, resolverType, parentTypeName, results) {
@@ -132,34 +146,68 @@ function collectInlineObjectsFromResolverArgs(field, resolverType, parentTypeNam
             context,
             sourceLocation: field.sourceLocation,
             nullable: arg.type.nullable,
+            description: null,
+            deprecated: null,
         });
-        extractNestedInlineObjectsFromArg(arg.inlineObjectProperties, resolverType, field.name, arg.name, parentTypeName, [], field.sourceLocation, results);
-    }
-}
-function extractNestedInlineObjectsFromArg(properties, resolverType, fieldName, argName, parentTypeName, currentPath, sourceLocation, results) {
-    for (const prop of properties) {
-        if (prop.tsType.kind === "inlineObject" &&
-            prop.tsType.inlineObjectProperties) {
-            const nestedPath = [...currentPath, prop.name];
-            const nestedContext = {
+        extractNestedInlineObjectsRecursively({
+            properties: arg.inlineObjectProperties,
+            currentPath: [],
+            sourceLocation: field.sourceLocation,
+            buildContext: (nestedPath) => ({
                 kind: "resolverArg",
                 resolverType,
-                fieldName,
-                argName,
+                fieldName: field.name,
+                argName: arg.name,
                 parentTypeName,
                 fieldPath: nestedPath,
-            };
-            results.push({
-                properties: prop.tsType.inlineObjectProperties,
-                context: nestedContext,
-                sourceLocation,
-                nullable: prop.tsType.nullable,
-            });
-            extractNestedInlineObjectsFromArg(prop.tsType.inlineObjectProperties, resolverType, fieldName, argName, parentTypeName, nestedPath, sourceLocation, results);
-        }
+            }),
+            preserveDocumentation: false,
+            results,
+        });
     }
 }
-function generateAutoType(inlineObj, generatedTypeNames) {
+function collectInlinePayloadsFromResolvers(resolversResult) {
+    const results = [];
+    forEachResolverField(resolversResult, ({ field, resolverType, parentTypeName }) => {
+        collectInlinePayloadFromReturnType(field, resolverType, parentTypeName, results);
+    });
+    return results;
+}
+function collectInlinePayloadFromReturnType(field, resolverType, parentTypeName, results) {
+    if (!field.returnTypeInlineObjectProperties)
+        return;
+    const context = {
+        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,
+    });
+}
+function generateAutoType(params) {
+    const { inlineObj, generatedTypeNames, enumTypeNames, unionTypeNames } = params;
     const name = generateAutoTypeName(inlineObj.context);
     const isInput = inlineObj.context.kind === "inputField" ||
         inlineObj.context.kind === "resolverArg";
@@ -178,7 +226,13 @@ function generateAutoType(inlineObj, generatedTypeNames) {
             });
             continue;
         }
-        const fieldType = resolveFieldType(prop, generatedTypeNames, inlineObj.context);
+        const fieldType = resolveFieldType({
+            prop,
+            generatedTypeNames,
+            enumTypeNames,
+            unionTypeNames,
+            parentContext: inlineObj.context,
+        });
         fields.push({
             name: prop.name,
             type: fieldType,
@@ -188,106 +242,195 @@ function generateAutoType(inlineObj, generatedTypeNames) {
             defaultValue: prop.defaultValue,
         });
     }
-    const generatedFrom = {
-        parentTypeName: inlineObj.context.parentTypeName,
-        fieldPath: inlineObj.context.kind === "resolverArg" &&
-            inlineObj.context.fieldPath.length === 0
-            ? [inlineObj.context.argName]
-            : inlineObj.context.fieldPath,
-        context: inlineObj.context.kind === "objectField"
-            ? "typeField"
-            : inlineObj.context.kind === "inputField"
-                ? "inputField"
-                : "resolverArg",
-    };
     return {
         type: {
             name,
             kind: isInput ? "InputObject" : "Object",
             fields,
+            enumValues: null,
+            unionMembers: null,
+            needsStringEnumMapping: false,
             sourceLocation: inlineObj.sourceLocation,
-            generatedFrom,
-            description: null,
+            generatedFrom: buildGeneratedFromInfo(inlineObj.context),
+            description: inlineObj.description,
+            resolveTypeFieldPattern: null,
         },
         diagnostics,
     };
 }
-function resolveFieldType(prop, generatedTypeNames, parentContext) {
+function tryResolveNestedType(prop, parentContext, typeNamesMap) {
+    const nestedPath = [...parentContext.fieldPath, prop.name];
+    const nestedContext = {
+        ...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) {
+    const { prop, generatedTypeNames, enumTypeNames, unionTypeNames, parentContext, } = params;
     if (prop.tsType.kind === "inlineObject" &&
         prop.tsType.inlineObjectProperties) {
-        const nestedPath = [...parentContext.fieldPath, prop.name];
-        const nestedContext = {
-            ...parentContext,
-            fieldPath: nestedPath,
-        };
-        const contextKey = getContextKey(nestedContext);
-        const resolvedTypeName = generatedTypeNames.get(contextKey);
-        if (resolvedTypeName) {
-            return {
-                typeName: resolvedTypeName,
-                nullable: prop.tsType.nullable || prop.optional,
-                list: false,
-                listItemNullable: null,
-            };
-        }
+        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);
 }
-function updateExtractedTypes(extractedTypes, generatedTypeNames) {
+function updateExtractedTypes(extractedTypes, params) {
     return extractedTypes.map((typeInfo) => {
         const isInput = isInputTypeName(typeInfo.metadata.name);
         return {
             ...typeInfo,
-            fields: typeInfo.fields.map((field) => updateField(field, generatedTypeNames, typeInfo.metadata.name, isInput)),
+            fields: typeInfo.fields.map((field) => updateField(field, params, typeInfo.metadata.name, isInput)),
         };
     });
 }
-function updateField(field, generatedTypeNames, parentTypeName, isInput) {
+function updateField(field, params, parentTypeName, isInput) {
+    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 context = isInput
-            ? { kind: "inputField", parentTypeName, fieldPath: [field.name] }
-            : { kind: "objectField", parentTypeName, fieldPath: [field.name] };
-        const contextKey = getContextKey(context);
         const resolvedTypeName = generatedTypeNames.get(contextKey);
         if (resolvedTypeName) {
             return {
                 ...field,
-                tsType: {
-                    kind: "reference",
+                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,
-                    elementType: null,
-                    members: null,
                     nullable: field.tsType.nullable,
-                    scalarInfo: null,
-                    inlineObjectProperties: null,
+                }),
+            };
+        }
+    }
+    // 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, generatedTypeNames) {
+function updateResolversResult(resolversResult, params) {
     return {
         ...resolversResult,
         queryFields: {
-            fields: resolversResult.queryFields.fields.map((field) => updateResolverField(field, generatedTypeNames, "query", null)),
+            fields: resolversResult.queryFields.fields.map((field) => updateResolverField(field, params, "query", null)),
         },
         mutationFields: {
-            fields: resolversResult.mutationFields.fields.map((field) => updateResolverField(field, generatedTypeNames, "mutation", null)),
+            fields: resolversResult.mutationFields.fields.map((field) => updateResolverField(field, params, "mutation", null)),
         },
         typeExtensions: resolversResult.typeExtensions.map((ext) => ({
             ...ext,
-            fields: ext.fields.map((field) => updateResolverField(field, generatedTypeNames, "field", ext.targetTypeName)),
+            fields: ext.fields.map((field) => updateResolverField(field, params, "field", ext.targetTypeName)),
         })),
     };
 }
-function updateResolverField(field, generatedTypeNames, resolverType, parentTypeName) {
-    if (!field.args)
-        return field;
+function updateResolverField(field, params, resolverType, parentTypeName) {
+    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 = {
+            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) => {
-        if (!arg.inlineObjectProperties)
-            return arg;
         const context = {
             kind: "resolverArg",
             resolverType,
@@ -297,20 +440,50 @@ function updateResolverField(field, generatedTypeNames, resolverType, parentType
             fieldPath: [],
         };
         const contextKey = getContextKey(context);
-        const resolvedTypeName = generatedTypeNames.get(contextKey);
-        if (resolvedTypeName) {
-            return {
-                ...arg,
-                type: {
-                    ...arg.type,
-                    typeName: resolvedTypeName,
-                },
-            };
+        // 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,
     };
 }
@@ -323,26 +496,547 @@ function buildGeneratedTypeNamesMap(inlineObjects) {
     }
     return map;
 }
+function toScreamingSnakeCase(value) {
+    return value
+        .replace(/[-\s]+/g, "_")
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+        .toUpperCase();
+}
+function convertInlineEnumMembers(params) {
+    const { members, enumName, sourceLocation } = params;
+    let needsStringEnumMapping = false;
+    const enumValues = [];
+    const diagnostics = [];
+    const convertedMembers = [];
+    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();
+    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 };
+}
+function generateAutoEnumType(inlineEnum, typeName) {
+    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,
+    };
+}
+function buildEnumTypeNamesMap(inlineEnums) {
+    const enumTypeNames = new Map();
+    const symbolToTypeName = new Map();
+    const symbolToContextKey = new Map();
+    const uniqueInlineEnums = [];
+    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) {
+    const unionTypeNames = new Map();
+    for (const inlineUnion of inlineUnions) {
+        const contextKey = getContextKey(inlineUnion.context);
+        const typeName = generateAutoTypeName(inlineUnion.context);
+        unionTypeNames.set(contextKey, typeName);
+    }
+    return unionTypeNames;
+}
+function processOneOfInputObjects(params) {
+    const { inlineUnions, knownTypeNames, typeMap, unionTypeNames } = params;
+    const types = [];
+    const diagnostics = [];
+    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 };
+}
+function processUnionTypes(params) {
+    const { inlineUnions, knownTypeNames, generatedTypeNames, enumTypeNames, unionTypeNames, typeMap, } = params;
+    const types = [];
+    const diagnostics = [];
+    const generatedTypenameTypes = new Map();
+    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 = 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) {
+    const fieldNames = new Set();
+    for (const info of memberTypenames.values()) {
+        fieldNames.add(info.fieldName);
+    }
+    if (fieldNames.size === 0) {
+        return { usedFieldNames: createFieldNameSet(["__typename"]) };
+    }
+    return { usedFieldNames: fieldNames };
+}
+function processInlineUnions(params) {
+    const { inlineUnions, knownTypeNames, generatedTypeNames, enumTypeNames, unionTypeNames, extractedTypes, } = params;
+    const typeMap = new Map();
+    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],
+    };
+}
+function generateOneOfFields(params) {
+    const { members, knownTypeNames } = params;
+    const fields = [];
+    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;
+}
+/**
+ * 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) {
+    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) {
+    const { members, generatedTypeNames, parentContext, types, generatedTypenameTypes, diagnostics, sourceLocation, } = params;
+    const memberNames = [];
+    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;
+            let contextKey;
+            if (extractedInfo !== null) {
+                memberTypeName = extractedInfo.typeName;
+                const nestedContext = {
+                    ...parentContext,
+                    fieldPath: [...parentContext.fieldPath, extractedInfo.typeName],
+                };
+                contextKey = getContextKey(nestedContext);
+            }
+            else {
+                const nestedContext = {
+                    ...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 = 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 = {
+                ...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, fields2) {
+    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, type2) {
+    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) {
     const inlineObjectsFromTypes = [];
     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 = [];
     const diagnostics = [];
     for (const inlineObj of allInlineObjects) {
-        const result = generateAutoType(inlineObj, generatedTypeNames);
+        const result = generateAutoType({
+            inlineObj,
+            generatedTypeNames,
+            enumTypeNames,
+            unionTypeNames,
+        });
         autoGeneratedTypes.push(result.type);
         diagnostics.push(...result.diagnostics);
     }
-    const updatedExtractedTypes = updateExtractedTypes(input.extractedTypes, generatedTypeNames);
-    const updatedResolversResult = updateResolversResult(input.resolversResult, generatedTypeNames);
+    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 = {
+        generatedTypeNames,
+        enumTypeNames,
+        unionTypeNames,
+    };
+    const updatedExtractedTypes = updateExtractedTypes(input.extractedTypes, updateParams);
+    const updatedResolversResult = updateResolversResult(input.resolversResult, updateParams);
     return {
         autoGeneratedTypes,
         updatedExtractedTypes,