fix(codegen): resolve transitive enum types referenced by input fields

Previously, generateCustomInputTypes only followed nested types whose
names ended with 'Input'. This meant enum types like VectorMetric
(referenced by VectorNearbyInput.metric) were silently dropped from
generated output, producing TypeScript with undefined type references.

Now follows all non-scalar types that exist in the typeRegistry,
including enums and other type kinds.

Added unit test verifying transitive enum resolution through
VectorNearbyInput → VectorMetric.

Author: pyramation

graphql/codegen/src/__tests__/codegen/input-types-generator.test.ts

@@ -966,6 +966,63 @@ describe('plugin-injected condition fields', () => {
 
     // The referenced VectorNearbyInput type should be generated as a custom input type
     expect(result.content).toContain('export interface VectorNearbyInput {');
+
+    // Transitively referenced enum type (VectorMetric) should also be generated
+    expect(result.content).toContain('VectorMetric');
+    expect(result.content).toContain('"L2"');
+    expect(result.content).toContain('"INNER_PRODUCT"');
+    expect(result.content).toContain('"COSINE"');
+  });
+
+  it('generates transitively referenced enum types from input fields', () => {
+    // This specifically tests that enum types referenced by input object fields
+    // are followed and generated, not just types ending with "Input".
+    // VectorNearbyInput.metric references VectorMetric (an ENUM),
+    // which must be included in the output.
+    const registry = createTypeRegistry({
+      ContactCondition: {
+        kind: 'INPUT_OBJECT',
+        name: 'ContactCondition',
+        inputFields: [
+          { name: 'id', type: createTypeRef('SCALAR', 'UUID') },
+          { name: 'name', type: createTypeRef('SCALAR', 'String') },
+          {
+            name: 'embeddingNearby',
+            type: createTypeRef('INPUT_OBJECT', 'VectorNearbyInput'),
+          },
+        ],
+      },
+      VectorNearbyInput: {
+        kind: 'INPUT_OBJECT',
+        name: 'VectorNearbyInput',
+        inputFields: [
+          {
+            name: 'vector',
+            type: createNonNull(createTypeRef('SCALAR', 'Vector')),
+          },
+          {
+            name: 'metric',
+            type: createTypeRef('ENUM', 'VectorMetric'),
+          },
+        ],
+      },
+      VectorMetric: {
+        kind: 'ENUM',
+        name: 'VectorMetric',
+        enumValues: ['L2', 'INNER_PRODUCT', 'COSINE'],
+      },
+    });
+
+    const result = generateInputTypesFile(registry, new Set(), [contactTable]);
+
+    // VectorNearbyInput should be generated (follows *Input pattern)
+    expect(result.content).toContain('export interface VectorNearbyInput {');
+
+    // VectorMetric enum should ALSO be generated (transitive enum resolution)
+    expect(result.content).toMatch(/export type VectorMetric\s*=/);
+    expect(result.content).toContain('"L2"');
+    expect(result.content).toContain('"INNER_PRODUCT"');
+    expect(result.content).toContain('"COSINE"');
   });
 
   it('does not duplicate fields already derived from table columns', () => {

graphql/codegen/src/core/codegen/orm/input-types-generator.ts

@@ -1616,12 +1616,13 @@ function generateCustomInputTypes(
           description: stripSmartComments(field.description, comments),
         });
 
-        // Follow nested Input types
+        // Follow nested types (Input objects, Enums, etc.) that exist in the registry
         const baseType = getTypeBaseName(field.type);
         if (
           baseType &&
-          baseType.endsWith('Input') &&
-          !generatedTypes.has(baseType)
+          !SCALAR_NAMES.has(baseType) &&
+          !generatedTypes.has(baseType) &&
+          typeRegistry.has(baseType)
         ) {
           typesToGenerate.add(baseType);
         }