@constructive-io/graphql-codegen 2.23.3 → 2.24.0

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

@@ -1,15 +1,10 @@
-import { createProject, createSourceFile, getMinimalFormattedOutput, createFileHeader, createInterface, createTypeAlias, addSectionComment, } from './ts-ast';
+import * as t from '@babel/types';
+import { generateCode } from './babel-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)
- */
+import { getGeneratedFileHeader } from './utils';
 const SKIP_TYPES = new Set([
     ...SCALAR_NAMES,
-    // GraphQL built-ins
     'Query',
     'Mutation',
     'Subscription',
@@ -19,27 +14,9 @@ const SKIP_TYPES = new Set([
     '__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, Patch, Condition,
- * or OrderBy types because they may be referenced by custom operations.
- * Previously Condition and OrderBy were skipped but they ARE needed for
- * custom queries like `schemata`, `apiSchemata`, etc.
- */
-const SKIP_TYPE_PATTERNS = [
-// Currently no patterns are skipped - all types may be needed by custom operations
-];
-// ============================================================================
-// Type Conversion Utilities
-// ============================================================================
-/**
- * Convert a CleanTypeRef to TypeScript type string
- */
+const SKIP_TYPE_PATTERNS = [];
 function typeRefToTs(typeRef) {
     if (typeRef.kind === 'NON_NULL') {
         if (typeRef.ofType) {
@@ -53,48 +30,26 @@ function typeRefToTs(typeRef) {
         }
         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) {
+function generateEnumTypes(typeRegistry, tableTypeNames) {
+    const statements = [];
     const generatedTypes = new Set();
-    addSectionComment(sourceFile, 'Enum Types');
     for (const [typeName, typeInfo] of typeRegistry) {
         if (typeInfo.kind !== 'ENUM')
             continue;
@@ -102,23 +57,17 @@ function addEnumTypes(sourceFile, typeRegistry, tableTypeNames) {
             continue;
         if (!typeInfo.enumValues || typeInfo.enumValues.length === 0)
             continue;
-        const values = typeInfo.enumValues.map((v) => `'${v}'`).join(' | ');
-        sourceFile.addTypeAlias(createTypeAlias(typeName, values));
+        const unionType = t.tsUnionType(typeInfo.enumValues.map((v) => t.tsLiteralType(t.stringLiteral(v))));
+        const typeAlias = t.tsTypeAliasDeclaration(t.identifier(typeName), null, unionType);
+        statements.push(t.exportNamedDeclaration(typeAlias));
         generatedTypes.add(typeName);
     }
-    return generatedTypes;
+    return { statements, 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) {
+function generateInputObjectTypes(typeRegistry, tableTypeNames, alreadyGenerated) {
+    const statements = [];
     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;
@@ -128,10 +77,6 @@ function addInputObjectTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGe
             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)
@@ -144,18 +89,14 @@ function addInputObjectTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGe
         if (!typeInfo || typeInfo.kind !== 'INPUT_OBJECT')
             continue;
         generatedTypes.add(typeName);
+        const properties = [];
         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 prop = t.tsPropertySignature(t.identifier(field.name), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(tsType))));
+                prop.optional = optional;
+                properties.push(prop);
                 const baseType = getTypeBaseName(field.type);
                 if (baseType &&
                     !generatedTypes.has(baseType) &&
@@ -166,25 +107,15 @@ function addInputObjectTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGe
                     }
                 }
             }
-            sourceFile.addInterface(createInterface(typeName, properties));
-        }
-        else {
-            // Empty input object
-            sourceFile.addInterface(createInterface(typeName, []));
         }
+        const interfaceDecl = t.tsInterfaceDeclaration(t.identifier(typeName), null, null, t.tsInterfaceBody(properties));
+        statements.push(t.exportNamedDeclaration(interfaceDecl));
     }
-    return generatedTypes;
+    return { statements, generatedTypes };
 }
-// ============================================================================
-// UNION Types Generator
-// ============================================================================
-/**
- * Add UNION types to source file
- */
-function addUnionTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGenerated) {
+function generateUnionTypes(typeRegistry, tableTypeNames, alreadyGenerated) {
+    const statements = [];
     const generatedTypes = new Set(alreadyGenerated);
-    const unionTypesToGenerate = new Set();
-    // Collect all UNION types
     for (const [typeName, typeInfo] of typeRegistry) {
         if (typeInfo.kind !== 'UNION')
             continue;
@@ -192,32 +123,17 @@ function addUnionTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGenerate
             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));
+        const unionType = t.tsUnionType(typeInfo.possibleTypes.map((pt) => t.tsTypeReference(t.identifier(pt))));
+        const typeAlias = t.tsTypeAliasDeclaration(t.identifier(typeName), null, unionType);
+        statements.push(t.exportNamedDeclaration(typeAlias));
         generatedTypes.add(typeName);
     }
-    return generatedTypes;
+    return { statements, 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) => {
@@ -239,30 +155,16 @@ function collectReturnTypesFromRootTypes(typeRegistry, tableTypeNames) {
         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) {
+function generatePayloadObjectTypes(typeRegistry, tableTypeNames, alreadyGenerated) {
+    const statements = [];
     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)
@@ -275,26 +177,21 @@ function addPayloadObjectTypes(sourceFile, typeRegistry, tableTypeNames, already
         if (!typeInfo || typeInfo.kind !== 'OBJECT')
             continue;
         generatedTypes.add(typeName);
+        const properties = [];
         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
+                const finalType = isNullable ? `${tsType} | null` : tsType;
+                const prop = t.tsPropertySignature(t.identifier(field.name), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(finalType))));
+                prop.optional = isNullable;
+                properties.push(prop);
                 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)) {
@@ -304,59 +201,41 @@ function addPayloadObjectTypes(sourceFile, typeRegistry, tableTypeNames, already
                     }
                 }
             }
-            sourceFile.addInterface(createInterface(typeName, properties));
-        }
-        else {
-            // Empty payload object
-            sourceFile.addInterface(createInterface(typeName, []));
         }
+        const interfaceDecl = t.tsInterfaceDeclaration(t.identifier(typeName), null, null, t.tsInterfaceBody(properties));
+        statements.push(t.exportNamedDeclaration(interfaceDecl));
     }
-    return { generatedTypes, referencedTableTypes };
+    return { statements, 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
+    const allStatements = [];
     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 enumResult = generateEnumTypes(typeRegistry, tableTypeNames);
+    generatedTypes = new Set([...generatedTypes, ...enumResult.generatedTypes]);
+    const unionResult = generateUnionTypes(typeRegistry, tableTypeNames, generatedTypes);
+    generatedTypes = new Set([...generatedTypes, ...unionResult.generatedTypes]);
+    const inputResult = generateInputObjectTypes(typeRegistry, tableTypeNames, generatedTypes);
+    generatedTypes = new Set([...generatedTypes, ...inputResult.generatedTypes]);
+    const payloadResult = generatePayloadObjectTypes(typeRegistry, tableTypeNames, generatedTypes);
     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);
+        const typesImport = t.importDeclaration(allTypesImports.map((ti) => t.importSpecifier(t.identifier(ti), t.identifier(ti))), t.stringLiteral('./types'));
+        typesImport.importKind = 'type';
+        allStatements.push(typesImport);
     }
+    allStatements.push(...enumResult.statements);
+    allStatements.push(...unionResult.statements);
+    allStatements.push(...inputResult.statements);
+    allStatements.push(...payloadResult.statements);
+    const code = generateCode(allStatements);
+    const content = getGeneratedFileHeader('GraphQL schema types for custom operations') + '\n\n' + code;
     return {
         fileName: 'schema-types.ts',
-        content: getMinimalFormattedOutput(sourceFile),
-        generatedEnums: Array.from(enumTypes).sort(),
+        content,
+        generatedEnums: Array.from(enumResult.generatedTypes).sort(),
         referencedTableTypes,
     };
 }

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

@@ -4,8 +4,7 @@
  * Utilities for converting CleanTypeRef and other GraphQL types
  * into TypeScript type strings and interface definitions.
  */
-import type { CleanTypeRef, CleanArgument, CleanObjectField } from '../../types/schema';
-import type { InterfaceProperty } from './ts-ast';
+import type { CleanTypeRef, CleanObjectField } from '../../types/schema';
 /**
  * Interface for tracking referenced types during code generation
  */
@@ -70,34 +69,6 @@ export declare function getTypeBaseName(typeRef: CleanTypeRef): string | null;
  * Get the base type kind (unwrapping LIST and NON_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, 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, 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[], 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[], tracker?: TypeTracker): InterfaceProperty[];
 /**
  * Check if a field should be skipped in selections
  */

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

@@ -161,55 +161,6 @@ export function getBaseTypeKind(typeRef) {
     return typeRef.kind;
 }
 // ============================================================================
-// Interface Property Generation
-// ============================================================================
-/**
- * Convert CleanArgument to InterfaceProperty for ts-morph
- *
- * @param arg - The GraphQL argument
- * @param tracker - Optional TypeTracker to collect referenced types
- */
-export function argumentToInterfaceProperty(arg, tracker) {
-    return {
-        name: arg.name,
-        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, tracker) {
-    return {
-        name: field.name,
-        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, 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, tracker) {
-    return fields.map((field) => fieldToInterfaceProperty(field, tracker));
-}
-// ============================================================================
 // Type Filtering
 // ============================================================================
 /**

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

@@ -1,5 +1,5 @@
 /**
- * Types generator - generates types.ts with entity interfaces using AST
+ * Types generator - generates types.ts with entity interfaces using Babel AST
  */
 import type { CleanTable } from '../../types/schema';
 /**

package/esm/cli/codegen/types.js

@@ -1,5 +1,6 @@
-import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, createInterface, } from './ts-ast';
-import { getScalarFields, fieldTypeToTs } from './utils';
+import * as t from '@babel/types';
+import { generateCode } from './babel-ast';
+import { getScalarFields, fieldTypeToTs, getGeneratedFileHeader } from './utils';
 /** All filter type configurations - scalar and list filters */
 const FILTER_CONFIGS = [
     // Scalar filters
@@ -64,16 +65,42 @@ function buildFilterProperties(tsType, operators) {
     }
     return props;
 }
+function parseTypeAnnotation(typeStr) {
+    if (typeStr === 'string')
+        return t.tsStringKeyword();
+    if (typeStr === 'number')
+        return t.tsNumberKeyword();
+    if (typeStr === 'boolean')
+        return t.tsBooleanKeyword();
+    if (typeStr === 'unknown')
+        return t.tsUnknownKeyword();
+    if (typeStr.includes(' | ')) {
+        const parts = typeStr.split(' | ').map((p) => parseTypeAnnotation(p.trim()));
+        return t.tsUnionType(parts);
+    }
+    if (typeStr.endsWith('[]')) {
+        return t.tsArrayType(parseTypeAnnotation(typeStr.slice(0, -2)));
+    }
+    if (typeStr === 'null')
+        return t.tsNullKeyword();
+    return t.tsTypeReference(t.identifier(typeStr));
+}
+function createInterfaceDeclaration(name, properties) {
+    const props = properties.map((prop) => {
+        const propSig = t.tsPropertySignature(t.identifier(prop.name), t.tsTypeAnnotation(parseTypeAnnotation(prop.type)));
+        propSig.optional = prop.optional ?? false;
+        return propSig;
+    });
+    const interfaceDecl = t.tsInterfaceDeclaration(t.identifier(name), null, null, t.tsInterfaceBody(props));
+    return t.exportNamedDeclaration(interfaceDecl);
+}
 /**
  * Generate types.ts content with all entity interfaces and base filter types
  */
 export function generateTypesFile(tables, options = {}) {
     const { enumsFromSchemaTypes = [] } = options;
     const enumSet = new Set(enumsFromSchemaTypes);
-    const project = createProject();
-    const sourceFile = createSourceFile(project, 'types.ts');
-    // Add file header
-    sourceFile.insertText(0, createFileHeader('Entity types and filter types') + '\n\n');
+    const statements = [];
     // Collect which enums are actually used by entity fields
     const usedEnums = new Set();
     for (const table of tables) {
@@ -88,16 +115,13 @@ export function generateTypesFile(tables, options = {}) {
     }
     // Add import for enum types from schema-types if any are used
     if (usedEnums.size > 0) {
-        sourceFile.addImportDeclaration(createImport({
-            moduleSpecifier: './schema-types',
-            typeOnlyNamedImports: Array.from(usedEnums).sort(),
-        }));
-        sourceFile.addStatements('');
+        const specifiers = Array.from(usedEnums)
+            .sort()
+            .map((name) => t.importSpecifier(t.identifier(name), t.identifier(name)));
+        const importDecl = t.importDeclaration(specifiers, t.stringLiteral('./schema-types'));
+        importDecl.importKind = 'type';
+        statements.push(importDecl);
     }
-    // Add section comment for entity types
-    sourceFile.addStatements('// ============================================================================');
-    sourceFile.addStatements('// Entity types');
-    sourceFile.addStatements('// ============================================================================\n');
     // Generate entity interfaces
     for (const table of tables) {
         const scalarFields = getScalarFields(table);
@@ -105,15 +129,13 @@ export function generateTypesFile(tables, options = {}) {
             name: field.name,
             type: `${fieldTypeToTs(field.type)} | null`,
         }));
-        sourceFile.addInterface(createInterface(table.name, properties));
+        statements.push(createInterfaceDeclaration(table.name, properties));
     }
-    // Add section comment for filter types
-    sourceFile.addStatements('\n// ============================================================================');
-    sourceFile.addStatements('// Filter types (shared PostGraphile filter interfaces)');
-    sourceFile.addStatements('// ============================================================================\n');
     // Generate all filter types
     for (const { name, tsType, operators } of FILTER_CONFIGS) {
-        sourceFile.addInterface(createInterface(name, buildFilterProperties(tsType, operators)));
+        statements.push(createInterfaceDeclaration(name, buildFilterProperties(tsType, operators)));
     }
-    return getFormattedOutput(sourceFile);
+    const header = getGeneratedFileHeader('Entity types and filter types');
+    const code = generateCode(statements);
+    return header + '\n' + code;
 }