@gqlkit-ts/cli 0.0.1 → 0.2.0

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

@@ -0,0 +1,925 @@
+import type ts from "typescript";
+import type {
+  ExtractResolversResult,
+  GraphQLFieldDefinition,
+} from "../resolver-extractor/index.js";
+import type {
+  DirectiveArgumentValue,
+  DirectiveInfo,
+} from "../shared/directive-detector.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 {
+  collectInlineEnumsFromResolvers,
+  collectInlineEnumsFromTypes,
+  type InlineEnumWithContext,
+} from "./inline-enum-collector.js";
+import {
+  type AutoTypeNameContext,
+  buildFieldContext,
+  generateAutoTypeName,
+} from "./naming-convention.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";
+}
+
+/**
+ * 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";
+  /** Fields for Object/InputObject kinds (null for Enum) */
+  readonly fields: ReadonlyArray<AutoGeneratedField> | null;
+  /** Enum values for Enum kind (null for Object/InputObject) */
+  readonly enumValues: ReadonlyArray<AutoGeneratedEnumValue> | 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;
+}
+
+export interface AutoTypeGeneratorInput {
+  readonly extractedTypes: ReadonlyArray<ExtractedTypeInfo>;
+  readonly resolversResult: ExtractResolversResult;
+}
+
+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;
+}
+
+function isInputTypeName(name: string): boolean {
+  return name.endsWith("Input");
+}
+
+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(".")}`;
+  }
+}
+
+function mapContextKindToGeneratedFromContext(
+  kind: AutoTypeNameContext["kind"],
+): GeneratedFromInfo["context"] {
+  switch (kind) {
+    case "objectField":
+      return "typeField";
+    case "inputField":
+      return "inputField";
+    case "resolverArg":
+      return "resolverArg";
+  }
+}
+
+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,
+      };
+
+  results.push({
+    properties: tsType.inlineObjectProperties,
+    context,
+    sourceLocation: field.sourceLocation ?? {
+      file: sourceFile,
+      line: 1,
+      column: 1,
+    },
+    nullable: tsType.nullable,
+  });
+
+  for (const prop of tsType.inlineObjectProperties) {
+    if (
+      prop.tsType.kind === "inlineObject" &&
+      prop.tsType.inlineObjectProperties
+    ) {
+      const nestedPath = [...fieldPath, prop.name];
+      const nestedContext: AutoTypeNameContext = 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: ReadonlyArray<InlineObjectPropertyDef>,
+  context: AutoTypeNameContext,
+  currentPath: ReadonlyArray<string>,
+  parentTypeName: string,
+  isInput: boolean,
+  sourceFile: string,
+  parentSourceLocation: SourceLocation | null,
+  results: InlineObjectWithContext[],
+): void {
+  results.push({
+    properties,
+    context,
+    sourceLocation: parentSourceLocation ?? {
+      file: sourceFile,
+      line: 1,
+      column: 1,
+    },
+    nullable: false,
+  });
+
+  for (const prop of properties) {
+    if (
+      prop.tsType.kind === "inlineObject" &&
+      prop.tsType.inlineObjectProperties
+    ) {
+      const nestedPath = [...currentPath, prop.name];
+      const nestedContext: AutoTypeNameContext = 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: ExtractResolversResult,
+): InlineObjectWithContext[] {
+  const results: InlineObjectWithContext[] = [];
+
+  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,
+      );
+    }
+  }
+
+  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,
+    });
+
+    extractNestedInlineObjectsFromArg(
+      arg.inlineObjectProperties,
+      resolverType,
+      field.name,
+      arg.name,
+      parentTypeName,
+      [],
+      field.sourceLocation,
+      results,
+    );
+  }
+}
+
+function extractNestedInlineObjectsFromArg(
+  properties: ReadonlyArray<InlineObjectPropertyDef>,
+  resolverType: "query" | "mutation" | "field",
+  fieldName: string,
+  argName: string,
+  parentTypeName: string | null,
+  currentPath: ReadonlyArray<string>,
+  sourceLocation: SourceLocation,
+  results: InlineObjectWithContext[],
+): void {
+  for (const prop of properties) {
+    if (
+      prop.tsType.kind === "inlineObject" &&
+      prop.tsType.inlineObjectProperties
+    ) {
+      const nestedPath = [...currentPath, prop.name];
+      const nestedContext: AutoTypeNameContext = {
+        kind: "resolverArg",
+        resolverType,
+        fieldName,
+        argName,
+        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,
+      );
+    }
+  }
+}
+
+interface GenerateAutoTypeResult {
+  readonly type: AutoGeneratedType;
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+}
+
+interface GenerateAutoTypeParams {
+  readonly inlineObj: InlineObjectWithContext;
+  readonly generatedTypeNames: Map<string, string>;
+  readonly enumTypeNames: Map<string, string>;
+}
+
+function generateAutoType(
+  params: GenerateAutoTypeParams,
+): GenerateAutoTypeResult {
+  const { inlineObj, generatedTypeNames, enumTypeNames } = 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,
+      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,
+      needsStringEnumMapping: false,
+      sourceLocation: inlineObj.sourceLocation,
+      generatedFrom: buildGeneratedFromInfo(inlineObj.context),
+      description: null,
+    },
+    diagnostics,
+  };
+}
+
+interface ResolveFieldTypeParams {
+  readonly prop: InlineObjectPropertyDef;
+  readonly generatedTypeNames: Map<string, string>;
+  readonly enumTypeNames: Map<string, string>;
+  readonly parentContext: AutoTypeNameContext;
+}
+
+function resolveFieldType(params: ResolveFieldTypeParams): GraphQLFieldType {
+  const { prop, generatedTypeNames, enumTypeNames, parentContext } = params;
+
+  if (
+    prop.tsType.kind === "inlineObject" &&
+    prop.tsType.inlineObjectProperties
+  ) {
+    const nestedPath = [...parentContext.fieldPath, prop.name];
+    const nestedContext: AutoTypeNameContext = {
+      ...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,
+      };
+    }
+  }
+
+  if (prop.tsType.kind === "inlineEnum" && prop.tsType.inlineEnumMembers) {
+    const nestedPath = [...parentContext.fieldPath, prop.name];
+    const nestedContext: AutoTypeNameContext = {
+      ...parentContext,
+      fieldPath: nestedPath,
+    };
+    const contextKey = getContextKey(nestedContext);
+    const resolvedTypeName = enumTypeNames.get(contextKey);
+    if (resolvedTypeName) {
+      return {
+        typeName: resolvedTypeName,
+        nullable: prop.tsType.nullable || prop.optional,
+        list: false,
+        listItemNullable: null,
+      };
+    }
+  }
+
+  return convertTsTypeToGraphQLType(prop.tsType, prop.optional);
+}
+
+interface UpdateTypeNamesParams {
+  readonly generatedTypeNames: Map<string, string>;
+  readonly enumTypeNames: 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 } = 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,
+          }),
+        },
+      };
+    }
+  }
+
+  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 {
+  if (!field.args) return field;
+
+  const { generatedTypeNames, enumTypeNames } = params;
+
+  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,
+          },
+        };
+      }
+    }
+
+    return arg;
+  });
+
+  return {
+    ...field,
+    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>;
+}
+
+function convertInlineEnumMembers(
+  params: ConvertInlineEnumMembersParams,
+): ConvertEnumMembersWithDiagnosticsResult {
+  const { members, enumName, sourceLocation } = params;
+  let needsStringEnumMapping = false;
+  const enumValues: AutoGeneratedEnumValue[] = [];
+  const diagnostics: Diagnostic[] = [];
+
+  const convertedNameToOriginals = new Map<string, string[]>();
+
+  for (const member of members) {
+    const convertedName = toScreamingSnakeCase(member.value);
+
+    if (convertedName !== member.value) {
+      needsStringEnumMapping = true;
+    }
+
+    const originals = convertedNameToOriginals.get(convertedName) ?? [];
+    originals.push(member.value);
+    convertedNameToOriginals.set(convertedName, originals);
+
+    enumValues.push({
+      name: convertedName,
+      originalValue: member.value,
+      description: member.description,
+      deprecated: member.deprecated,
+    });
+  }
+
+  for (const [convertedName, originals] of convertedNameToOriginals) {
+    if (originals.length > 1) {
+      diagnostics.push({
+        code: "DUPLICATE_ENUM_VALUE_AFTER_CONVERSION",
+        message: `Enum '${enumName}' has duplicate value '${convertedName}' 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,
+      needsStringEnumMapping,
+      sourceLocation: inlineEnum.sourceLocation,
+      generatedFrom: buildGeneratedFromInfo(inlineEnum.context),
+      description: inlineEnum.externalEnumDescription,
+    },
+    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,
+  };
+}
+
+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 allInlineObjects = [
+    ...inlineObjectsFromTypes,
+    ...inlineObjectsFromResolvers,
+  ];
+
+  const generatedTypeNames = buildGeneratedTypeNamesMap(allInlineObjects);
+
+  const inlineEnumsFromTypes = collectInlineEnumsFromTypes(
+    input.extractedTypes,
+  );
+  const inlineEnumsFromResolvers = collectInlineEnumsFromResolvers(
+    input.resolversResult,
+  );
+  const allInlineEnums = [...inlineEnumsFromTypes, ...inlineEnumsFromResolvers];
+
+  const { enumTypeNames, uniqueInlineEnums } =
+    buildEnumTypeNamesMap(allInlineEnums);
+
+  const autoGeneratedTypes: AutoGeneratedType[] = [];
+  const diagnostics: Diagnostic[] = [];
+
+  for (const inlineObj of allInlineObjects) {
+    const result = generateAutoType({
+      inlineObj,
+      generatedTypeNames,
+      enumTypeNames,
+    });
+    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);
+  }
+
+  const updateParams: UpdateTypeNamesParams = {
+    generatedTypeNames,
+    enumTypeNames,
+  };
+
+  const updatedExtractedTypes = updateExtractedTypes(
+    input.extractedTypes,
+    updateParams,
+  );
+
+  const updatedResolversResult = updateResolversResult(
+    input.resolversResult,
+    updateParams,
+  );
+
+  return {
+    autoGeneratedTypes,
+    updatedExtractedTypes,
+    updatedResolversResult,
+    diagnostics,
+  };
+}