@constructive-io/graphql-codegen 2.20.1 → 2.22.0

package/esm/cli/codegen/schema-types-generator.js

@@ -0,0 +1,362 @@
+import { createProject, createSourceFile, getMinimalFormattedOutput, createFileHeader, createInterface, createTypeAlias, addSectionComment, } from './ts-ast';
+import { getTypeBaseName } from './type-resolver';
+import { scalarToTsType, SCALAR_NAMES, BASE_FILTER_TYPE_NAMES } from './scalars';
+// ============================================================================
+// Constants
+// ============================================================================
+/**
+ * Types that should not be generated (scalars, built-ins, types generated elsewhere)
+ */
+const SKIP_TYPES = new Set([
+    ...SCALAR_NAMES,
+    // GraphQL built-ins
+    'Query',
+    'Mutation',
+    'Subscription',
+    '__Schema',
+    '__Type',
+    '__Field',
+    '__InputValue',
+    '__EnumValue',
+    '__Directive',
+    // Note: PageInfo and Cursor are NOT skipped - they're needed by Connection types
+    // Base filter types (generated in types.ts via filters.ts)
+    ...BASE_FILTER_TYPE_NAMES,
+]);
+/**
+ * Type name patterns to skip (regex patterns)
+ *
+ * Note: We intentionally DO NOT skip Connection, Edge, Filter, or Patch types
+ * because they may be referenced by custom operations or payload types.
+ * Only skip Condition and OrderBy which are typically not needed.
+ */
+const SKIP_TYPE_PATTERNS = [
+    /Condition$/, // e.g., UserCondition (filter conditions are separate)
+    /OrderBy$/, // e.g., UsersOrderBy (ordering is handled separately)
+];
+// ============================================================================
+// Type Conversion Utilities
+// ============================================================================
+/**
+ * Convert a CleanTypeRef to TypeScript type string
+ */
+function typeRefToTs(typeRef) {
+    if (typeRef.kind === 'NON_NULL') {
+        if (typeRef.ofType) {
+            return typeRefToTs(typeRef.ofType);
+        }
+        return typeRef.name ?? 'unknown';
+    }
+    if (typeRef.kind === 'LIST') {
+        if (typeRef.ofType) {
+            return `${typeRefToTs(typeRef.ofType)}[]`;
+        }
+        return 'unknown[]';
+    }
+    // Scalar or named type
+    const name = typeRef.name ?? 'unknown';
+    return scalarToTsType(name, { unknownScalar: 'name' });
+}
+/**
+ * Check if a type is required (NON_NULL)
+ */
+function isRequired(typeRef) {
+    return typeRef.kind === 'NON_NULL';
+}
+/**
+ * Check if a type should be skipped
+ */
+function shouldSkipType(typeName, tableTypeNames) {
+    // Skip scalars and built-ins
+    if (SKIP_TYPES.has(typeName))
+        return true;
+    // Skip table entity types (already in types.ts)
+    if (tableTypeNames.has(typeName))
+        return true;
+    // Skip types matching patterns
+    for (const pattern of SKIP_TYPE_PATTERNS) {
+        if (pattern.test(typeName))
+            return true;
+    }
+    // Skip table-specific types that would conflict with inline types in table-based hooks.
+    // Note: Patch and CreateInput are now NOT exported from hooks (isExported: false),
+    // so we only skip Filter types here.
+    // The Filter and OrderBy types are generated inline (non-exported) by table query hooks,
+    // but schema-types should still generate them for custom operations that need them.
+    // Actually, we don't skip any table-based types now since hooks don't export them.
+    return false;
+}
+// ============================================================================
+// ENUM Types Generator
+// ============================================================================
+/**
+ * Add ENUM types to source file
+ */
+function addEnumTypes(sourceFile, typeRegistry, tableTypeNames) {
+    const generatedTypes = new Set();
+    addSectionComment(sourceFile, 'Enum Types');
+    for (const [typeName, typeInfo] of typeRegistry) {
+        if (typeInfo.kind !== 'ENUM')
+            continue;
+        if (shouldSkipType(typeName, tableTypeNames))
+            continue;
+        if (!typeInfo.enumValues || typeInfo.enumValues.length === 0)
+            continue;
+        const values = typeInfo.enumValues.map((v) => `'${v}'`).join(' | ');
+        sourceFile.addTypeAlias(createTypeAlias(typeName, values));
+        generatedTypes.add(typeName);
+    }
+    return generatedTypes;
+}
+// ============================================================================
+// INPUT_OBJECT Types Generator
+// ============================================================================
+/**
+ * Add INPUT_OBJECT types to source file
+ * Uses iteration to handle nested input types
+ */
+function addInputObjectTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGenerated) {
+    const generatedTypes = new Set(alreadyGenerated);
+    const typesToGenerate = new Set();
+    // Collect all INPUT_OBJECT types
+    for (const [typeName, typeInfo] of typeRegistry) {
+        if (typeInfo.kind !== 'INPUT_OBJECT')
+            continue;
+        if (shouldSkipType(typeName, tableTypeNames))
+            continue;
+        if (generatedTypes.has(typeName))
+            continue;
+        typesToGenerate.add(typeName);
+    }
+    if (typesToGenerate.size === 0)
+        return generatedTypes;
+    addSectionComment(sourceFile, 'Input Object Types');
+    // Process all types - no artificial limit
+    while (typesToGenerate.size > 0) {
+        const typeNameResult = typesToGenerate.values().next();
+        if (typeNameResult.done)
+            break;
+        const typeName = typeNameResult.value;
+        typesToGenerate.delete(typeName);
+        if (generatedTypes.has(typeName))
+            continue;
+        const typeInfo = typeRegistry.get(typeName);
+        if (!typeInfo || typeInfo.kind !== 'INPUT_OBJECT')
+            continue;
+        generatedTypes.add(typeName);
+        if (typeInfo.inputFields && typeInfo.inputFields.length > 0) {
+            const properties = [];
+            for (const field of typeInfo.inputFields) {
+                const optional = !isRequired(field.type);
+                const tsType = typeRefToTs(field.type);
+                properties.push({
+                    name: field.name,
+                    type: tsType,
+                    optional,
+                    docs: field.description ? [field.description] : undefined,
+                });
+                // Follow nested Input types
+                const baseType = getTypeBaseName(field.type);
+                if (baseType &&
+                    !generatedTypes.has(baseType) &&
+                    !shouldSkipType(baseType, tableTypeNames)) {
+                    const nestedType = typeRegistry.get(baseType);
+                    if (nestedType?.kind === 'INPUT_OBJECT') {
+                        typesToGenerate.add(baseType);
+                    }
+                }
+            }
+            sourceFile.addInterface(createInterface(typeName, properties));
+        }
+        else {
+            // Empty input object
+            sourceFile.addInterface(createInterface(typeName, []));
+        }
+    }
+    return generatedTypes;
+}
+// ============================================================================
+// UNION Types Generator
+// ============================================================================
+/**
+ * Add UNION types to source file
+ */
+function addUnionTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGenerated) {
+    const generatedTypes = new Set(alreadyGenerated);
+    const unionTypesToGenerate = new Set();
+    // Collect all UNION types
+    for (const [typeName, typeInfo] of typeRegistry) {
+        if (typeInfo.kind !== 'UNION')
+            continue;
+        if (shouldSkipType(typeName, tableTypeNames))
+            continue;
+        if (generatedTypes.has(typeName))
+            continue;
+        unionTypesToGenerate.add(typeName);
+    }
+    if (unionTypesToGenerate.size === 0)
+        return generatedTypes;
+    addSectionComment(sourceFile, 'Union Types');
+    for (const typeName of unionTypesToGenerate) {
+        const typeInfo = typeRegistry.get(typeName);
+        if (!typeInfo || typeInfo.kind !== 'UNION')
+            continue;
+        if (!typeInfo.possibleTypes || typeInfo.possibleTypes.length === 0)
+            continue;
+        // Generate union type as TypeScript union
+        const unionMembers = typeInfo.possibleTypes.join(' | ');
+        sourceFile.addTypeAlias(createTypeAlias(typeName, unionMembers));
+        generatedTypes.add(typeName);
+    }
+    return generatedTypes;
+}
+/**
+ * Collect return types from Query and Mutation root types
+ * This dynamically discovers what OBJECT types need to be generated
+ * based on actual schema structure, not pattern matching
+ */
+function collectReturnTypesFromRootTypes(typeRegistry, tableTypeNames) {
+    const returnTypes = new Set();
+    // Get Query and Mutation root types
+    const queryType = typeRegistry.get('Query');
+    const mutationType = typeRegistry.get('Mutation');
+    const processFields = (fields) => {
+        if (!fields)
+            return;
+        for (const field of fields) {
+            const baseType = getTypeBaseName(field.type);
+            if (baseType && !shouldSkipType(baseType, tableTypeNames)) {
+                const typeInfo = typeRegistry.get(baseType);
+                if (typeInfo?.kind === 'OBJECT') {
+                    returnTypes.add(baseType);
+                }
+            }
+        }
+    };
+    if (queryType?.fields)
+        processFields(queryType.fields);
+    if (mutationType?.fields)
+        processFields(mutationType.fields);
+    return returnTypes;
+}
+/**
+ * Add Payload OBJECT types to source file
+ * These are return types from mutations (e.g., LoginPayload, BootstrapUserPayload)
+ *
+ * Also tracks which table entity types are referenced so they can be imported.
+ *
+ * Uses dynamic type discovery from Query/Mutation return types instead of pattern matching.
+ */
+function addPayloadObjectTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGenerated) {
+    const generatedTypes = new Set(alreadyGenerated);
+    const referencedTableTypes = new Set();
+    // Dynamically collect return types from Query and Mutation
+    const typesToGenerate = collectReturnTypesFromRootTypes(typeRegistry, tableTypeNames);
+    // Filter out already generated types
+    for (const typeName of Array.from(typesToGenerate)) {
+        if (generatedTypes.has(typeName)) {
+            typesToGenerate.delete(typeName);
+        }
+    }
+    if (typesToGenerate.size === 0) {
+        return { generatedTypes, referencedTableTypes };
+    }
+    addSectionComment(sourceFile, 'Payload/Return Object Types');
+    // Process all types - no artificial limit
+    while (typesToGenerate.size > 0) {
+        const typeNameResult = typesToGenerate.values().next();
+        if (typeNameResult.done)
+            break;
+        const typeName = typeNameResult.value;
+        typesToGenerate.delete(typeName);
+        if (generatedTypes.has(typeName))
+            continue;
+        const typeInfo = typeRegistry.get(typeName);
+        if (!typeInfo || typeInfo.kind !== 'OBJECT')
+            continue;
+        generatedTypes.add(typeName);
+        if (typeInfo.fields && typeInfo.fields.length > 0) {
+            const properties = [];
+            for (const field of typeInfo.fields) {
+                const baseType = getTypeBaseName(field.type);
+                // Skip Query and Mutation fields
+                if (baseType === 'Query' || baseType === 'Mutation')
+                    continue;
+                const tsType = typeRefToTs(field.type);
+                const isNullable = !isRequired(field.type);
+                properties.push({
+                    name: field.name,
+                    type: isNullable ? `${tsType} | null` : tsType,
+                    optional: isNullable,
+                    docs: field.description ? [field.description] : undefined,
+                });
+                // Track table entity types that are referenced
+                if (baseType && tableTypeNames.has(baseType)) {
+                    referencedTableTypes.add(baseType);
+                }
+                // Follow nested OBJECT types that aren't table types
+                if (baseType &&
+                    !generatedTypes.has(baseType) &&
+                    !shouldSkipType(baseType, tableTypeNames)) {
+                    const nestedType = typeRegistry.get(baseType);
+                    if (nestedType?.kind === 'OBJECT') {
+                        typesToGenerate.add(baseType);
+                    }
+                }
+            }
+            sourceFile.addInterface(createInterface(typeName, properties));
+        }
+        else {
+            // Empty payload object
+            sourceFile.addInterface(createInterface(typeName, []));
+        }
+    }
+    return { generatedTypes, referencedTableTypes };
+}
+// ============================================================================
+// Main Generator
+// ============================================================================
+/**
+ * Generate comprehensive schema-types.ts file using ts-morph AST
+ *
+ * This generates all Input/Payload/Enum types from the TypeRegistry
+ * that are needed by custom mutation/query hooks.
+ */
+export function generateSchemaTypesFile(options) {
+    const { typeRegistry, tableTypeNames } = options;
+    const project = createProject();
+    const sourceFile = createSourceFile(project, 'schema-types.ts');
+    // Add file header
+    sourceFile.insertText(0, createFileHeader('GraphQL schema types for custom operations') + '\n');
+    // Track all generated types
+    let generatedTypes = new Set();
+    // 1. Generate ENUM types
+    const enumTypes = addEnumTypes(sourceFile, typeRegistry, tableTypeNames);
+    generatedTypes = new Set([...generatedTypes, ...enumTypes]);
+    // 2. Generate UNION types
+    const unionTypes = addUnionTypes(sourceFile, typeRegistry, tableTypeNames, generatedTypes);
+    generatedTypes = new Set([...generatedTypes, ...unionTypes]);
+    // 3. Generate INPUT_OBJECT types
+    const inputTypes = addInputObjectTypes(sourceFile, typeRegistry, tableTypeNames, generatedTypes);
+    generatedTypes = new Set([...generatedTypes, ...inputTypes]);
+    // 4. Generate Payload OBJECT types
+    const payloadResult = addPayloadObjectTypes(sourceFile, typeRegistry, tableTypeNames, generatedTypes);
+    // 5. Add imports from types.ts (table entity types + base filter types)
+    const referencedTableTypes = Array.from(payloadResult.referencedTableTypes).sort();
+    // Always import base filter types since generated Filter interfaces reference them
+    const baseFilterImports = Array.from(BASE_FILTER_TYPE_NAMES).sort();
+    const allTypesImports = [...referencedTableTypes, ...baseFilterImports];
+    if (allTypesImports.length > 0) {
+        // Insert import after the file header comment
+        const importStatement = `import type { ${allTypesImports.join(', ')} } from './types';\n\n`;
+        // Find position after header (after first */ + newlines)
+        const headerEndIndex = sourceFile.getFullText().indexOf('*/') + 3;
+        sourceFile.insertText(headerEndIndex, '\n' + importStatement);
+    }
+    return {
+        fileName: 'schema-types.ts',
+        content: getMinimalFormattedOutput(sourceFile),
+        generatedEnums: Array.from(enumTypes).sort(),
+        referencedTableTypes,
+    };
+}

package/esm/cli/codegen/ts-ast.d.ts

@@ -66,7 +66,9 @@ export declare function createInterface(name: string, properties: InterfacePrope
 export declare function createFilterInterface(name: string, fieldFilters: Array<{
     fieldName: string;
     filterType: string;
-}>): InterfaceDeclarationStructure;
+}>, options?: {
+    isExported?: boolean;
+}): InterfaceDeclarationStructure;
 /**
  * Create type alias declaration structure
  */

package/esm/cli/codegen/ts-ast.js

@@ -143,7 +143,7 @@ export function createInterface(name, properties, options) {
 /**
  * Create filter interface with standard PostGraphile operators
  */
-export function createFilterInterface(name, fieldFilters) {
+export function createFilterInterface(name, fieldFilters, options) {
     const properties = [
         ...fieldFilters.map((f) => ({
             name: f.fieldName,
@@ -154,7 +154,7 @@ export function createFilterInterface(name, fieldFilters) {
         { name: 'or', type: `${name}[]`, optional: true, docs: ['Logical OR'] },
         { name: 'not', type: name, optional: true, docs: ['Logical NOT'] },
     ];
-    return createInterface(name, properties);
+    return createInterface(name, properties, { isExported: options?.isExported ?? true });
 }
 // ============================================================================
 // Type alias builders

package/esm/cli/codegen/type-resolver.d.ts

@@ -6,6 +6,34 @@
  */
 import type { CleanTypeRef, CleanArgument, CleanObjectField } from '../../types/schema';
 import type { InterfaceProperty } from './ts-ast';
+/**
+ * Interface for tracking referenced types during code generation
+ */
+export interface TypeTracker {
+    /** Set of type names that have been referenced */
+    referencedTypes: Set<string>;
+    /** Track a type reference */
+    track(typeName: string): void;
+    /** Get importable types from schema-types.ts (Input/Payload/Enum types) */
+    getImportableTypes(): string[];
+    /** Get importable types from types.ts (table entity types) */
+    getTableTypes(): string[];
+    /** Reset the tracker */
+    reset(): void;
+}
+/**
+ * Options for creating a TypeTracker
+ */
+export interface TypeTrackerOptions {
+    /** Table entity type names that should be imported from types.ts */
+    tableTypeNames?: Set<string>;
+}
+/**
+ * Create a new TypeTracker instance
+ *
+ * @param options - Optional configuration for the tracker
+ */
+export declare function createTypeTracker(options?: TypeTrackerOptions): TypeTracker;
 /**
  * Convert a GraphQL scalar type to TypeScript type
  */
@@ -13,13 +41,19 @@ export declare function scalarToTsType(scalarName: string): string;
 /**
  * Convert a CleanTypeRef to a TypeScript type string
  * Handles nested LIST and NON_NULL wrappers
+ *
+ * @param typeRef - The GraphQL type reference
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export declare function typeRefToTsType(typeRef: CleanTypeRef): string;
+export declare function typeRefToTsType(typeRef: CleanTypeRef, tracker?: TypeTracker): string;
 /**
  * Convert a CleanTypeRef to a nullable TypeScript type string
  * (for optional fields that can be null)
+ *
+ * @param typeRef - The GraphQL type reference
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export declare function typeRefToNullableTsType(typeRef: CleanTypeRef): string;
+export declare function typeRefToNullableTsType(typeRef: CleanTypeRef, tracker?: TypeTracker): string;
 /**
  * Check if a type reference is required (wrapped in NON_NULL)
  */
@@ -38,20 +72,32 @@ export declare function getTypeBaseName(typeRef: CleanTypeRef): string | null;
 export declare function getBaseTypeKind(typeRef: CleanTypeRef): CleanTypeRef['kind'];
 /**
  * Convert CleanArgument to InterfaceProperty for ts-morph
+ *
+ * @param arg - The GraphQL argument
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export declare function argumentToInterfaceProperty(arg: CleanArgument): InterfaceProperty;
+export declare function argumentToInterfaceProperty(arg: CleanArgument, tracker?: TypeTracker): InterfaceProperty;
 /**
  * Convert CleanObjectField to InterfaceProperty for ts-morph
+ *
+ * @param field - The GraphQL object field
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export declare function fieldToInterfaceProperty(field: CleanObjectField): InterfaceProperty;
+export declare function fieldToInterfaceProperty(field: CleanObjectField, tracker?: TypeTracker): InterfaceProperty;
 /**
  * Convert an array of CleanArguments to InterfaceProperty array
+ *
+ * @param args - The GraphQL arguments
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export declare function argumentsToInterfaceProperties(args: CleanArgument[]): InterfaceProperty[];
+export declare function argumentsToInterfaceProperties(args: CleanArgument[], tracker?: TypeTracker): InterfaceProperty[];
 /**
  * Convert an array of CleanObjectFields to InterfaceProperty array
+ *
+ * @param fields - The GraphQL object fields
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export declare function fieldsToInterfaceProperties(fields: CleanObjectField[]): InterfaceProperty[];
+export declare function fieldsToInterfaceProperties(fields: CleanObjectField[], tracker?: TypeTracker): InterfaceProperty[];
 /**
  * Check if a field should be skipped in selections
  */

package/esm/cli/codegen/type-resolver.js

@@ -1,4 +1,57 @@
-import { scalarToTsType as resolveScalarToTs } from './scalars';
+import { scalarToTsType as resolveScalarToTs, SCALAR_NAMES } from './scalars';
+// ============================================================================
+// Type Tracker for Collecting Referenced Types
+// ============================================================================
+/**
+ * Types that should not be tracked (scalars, built-ins, internal types)
+ */
+const SKIP_TYPE_TRACKING = new Set([
+    ...SCALAR_NAMES,
+    // GraphQL built-ins
+    'Query',
+    'Mutation',
+    'Subscription',
+    '__Schema',
+    '__Type',
+    '__Field',
+    '__InputValue',
+    '__EnumValue',
+    '__Directive',
+    // Connection types (handled separately)
+    'PageInfo',
+]);
+/**
+ * Create a new TypeTracker instance
+ *
+ * @param options - Optional configuration for the tracker
+ */
+export function createTypeTracker(options) {
+    const referencedTypes = new Set();
+    const tableTypeNames = options?.tableTypeNames ?? new Set();
+    return {
+        referencedTypes,
+        track(typeName) {
+            if (typeName && !SKIP_TYPE_TRACKING.has(typeName)) {
+                referencedTypes.add(typeName);
+            }
+        },
+        getImportableTypes() {
+            // Return schema types (not table entity types)
+            return Array.from(referencedTypes)
+                .filter((name) => !tableTypeNames.has(name))
+                .sort();
+        },
+        getTableTypes() {
+            // Return table entity types only
+            return Array.from(referencedTypes)
+                .filter((name) => tableTypeNames.has(name))
+                .sort();
+        },
+        reset() {
+            referencedTypes.clear();
+        },
+    };
+}
 // ============================================================================
 // GraphQL to TypeScript Type Mapping
 // ============================================================================
@@ -14,32 +67,41 @@ export function scalarToTsType(scalarName) {
 /**
  * Convert a CleanTypeRef to a TypeScript type string
  * Handles nested LIST and NON_NULL wrappers
+ *
+ * @param typeRef - The GraphQL type reference
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export function typeRefToTsType(typeRef) {
+export function typeRefToTsType(typeRef, tracker) {
     switch (typeRef.kind) {
         case 'NON_NULL':
             // Non-null wrapper - unwrap and return the inner type
             if (typeRef.ofType) {
-                return typeRefToTsType(typeRef.ofType);
+                return typeRefToTsType(typeRef.ofType, tracker);
             }
             return 'unknown';
         case 'LIST':
             // List wrapper - wrap inner type in array
             if (typeRef.ofType) {
-                const innerType = typeRefToTsType(typeRef.ofType);
+                const innerType = typeRefToTsType(typeRef.ofType, tracker);
                 return `${innerType}[]`;
             }
             return 'unknown[]';
         case 'SCALAR':
             // Scalar type - map to TS type
             return scalarToTsType(typeRef.name ?? 'unknown');
-        case 'ENUM':
-            // Enum type - use the GraphQL enum name
-            return typeRef.name ?? 'string';
+        case 'ENUM': {
+            // Enum type - use the GraphQL enum name and track it
+            const typeName = typeRef.name ?? 'string';
+            tracker?.track(typeName);
+            return typeName;
+        }
         case 'OBJECT':
-        case 'INPUT_OBJECT':
-            // Object types - use the GraphQL type name
-            return typeRef.name ?? 'unknown';
+        case 'INPUT_OBJECT': {
+            // Object types - use the GraphQL type name and track it
+            const typeName = typeRef.name ?? 'unknown';
+            tracker?.track(typeName);
+            return typeName;
+        }
         default:
             return 'unknown';
     }
@@ -47,9 +109,12 @@ export function typeRefToTsType(typeRef) {
 /**
  * Convert a CleanTypeRef to a nullable TypeScript type string
  * (for optional fields that can be null)
+ *
+ * @param typeRef - The GraphQL type reference
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export function typeRefToNullableTsType(typeRef) {
-    const baseType = typeRefToTsType(typeRef);
+export function typeRefToNullableTsType(typeRef, tracker) {
+    const baseType = typeRefToTsType(typeRef, tracker);
     // If the outer type is NON_NULL, it's required
     if (typeRef.kind === 'NON_NULL') {
         return baseType;
@@ -100,37 +165,49 @@ export function getBaseTypeKind(typeRef) {
 // ============================================================================
 /**
  * Convert CleanArgument to InterfaceProperty for ts-morph
+ *
+ * @param arg - The GraphQL argument
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export function argumentToInterfaceProperty(arg) {
+export function argumentToInterfaceProperty(arg, tracker) {
     return {
         name: arg.name,
-        type: typeRefToTsType(arg.type),
+        type: typeRefToTsType(arg.type, tracker),
         optional: !isTypeRequired(arg.type),
         docs: arg.description ? [arg.description] : undefined,
     };
 }
 /**
  * Convert CleanObjectField to InterfaceProperty for ts-morph
+ *
+ * @param field - The GraphQL object field
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export function fieldToInterfaceProperty(field) {
+export function fieldToInterfaceProperty(field, tracker) {
     return {
         name: field.name,
-        type: typeRefToNullableTsType(field.type),
+        type: typeRefToNullableTsType(field.type, tracker),
         optional: false, // Fields are always present, just potentially null
         docs: field.description ? [field.description] : undefined,
     };
 }
 /**
  * Convert an array of CleanArguments to InterfaceProperty array
+ *
+ * @param args - The GraphQL arguments
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export function argumentsToInterfaceProperties(args) {
-    return args.map(argumentToInterfaceProperty);
+export function argumentsToInterfaceProperties(args, tracker) {
+    return args.map((arg) => argumentToInterfaceProperty(arg, tracker));
 }
 /**
  * Convert an array of CleanObjectFields to InterfaceProperty array
+ *
+ * @param fields - The GraphQL object fields
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export function fieldsToInterfaceProperties(fields) {
-    return fields.map(fieldToInterfaceProperty);
+export function fieldsToInterfaceProperties(fields, tracker) {
+    return fields.map((field) => fieldToInterfaceProperty(field, tracker));
 }
 // ============================================================================
 // Type Filtering

package/esm/cli/codegen/types.d.ts

@@ -3,10 +3,13 @@
  */
 import type { CleanTable } from '../../types/schema';
 /**
- * Generate types.ts content with all entity interfaces and base filter types
+ * Options for generating types.ts
  */
-export declare function generateTypesFile(tables: CleanTable[]): string;
+export interface GenerateTypesOptions {
+    /** Enum type names that are available from schema-types.ts */
+    enumsFromSchemaTypes?: string[];
+}
 /**
- * Generate a minimal entity type (just id and display fields)
+ * Generate types.ts content with all entity interfaces and base filter types
  */
-export declare function generateMinimalEntityType(table: CleanTable): string;
+export declare function generateTypesFile(tables: CleanTable[], options?: GenerateTypesOptions): string;