@constructive-io/graphql-codegen 2.23.2 → 2.24.0

package/esm/cli/codegen/orm/input-types-generator.js

@@ -1,5 +1,6 @@
-import { createProject, createSourceFile, getMinimalFormattedOutput, createFileHeader, createInterface, createTypeAlias, addSectionComment, } from '../ts-ast';
-import { getTableNames, getFilterTypeName, getConditionTypeName, getOrderByTypeName, isRelationField, } from '../utils';
+import * as t from '@babel/types';
+import { generateCode, addLineComment } from '../babel-ast';
+import { getTableNames, getFilterTypeName, getConditionTypeName, getOrderByTypeName, isRelationField, getGeneratedFileHeader, } from '../utils';
 import { pluralize } from 'inflekt';
 import { getTypeBaseName } from '../type-resolver';
 import { scalarToTsType, scalarToFilterType } from '../scalars';
@@ -57,6 +58,86 @@ function typeRefToTs(typeRef) {
 function isRequired(typeRef) {
     return typeRef.kind === 'NON_NULL';
 }
+// ============================================================================
+// Babel AST Helper Functions
+// ============================================================================
+/**
+ * Parse a type string into a TSType node
+ */
+function parseTypeString(typeStr) {
+    // Handle union types like "string | null"
+    if (typeStr.includes(' | ')) {
+        const parts = typeStr.split(' | ').map((p) => p.trim());
+        return t.tsUnionType(parts.map((p) => parseTypeString(p)));
+    }
+    // Handle array types like "string[]"
+    if (typeStr.endsWith('[]')) {
+        const elementType = typeStr.slice(0, -2);
+        return t.tsArrayType(parseTypeString(elementType));
+    }
+    // Handle generic types like "Record<string, unknown>"
+    if (typeStr.includes('<')) {
+        const match = typeStr.match(/^([^<]+)<(.+)>$/);
+        if (match) {
+            const [, baseName, params] = match;
+            const typeParams = params.split(',').map((p) => parseTypeString(p.trim()));
+            return t.tsTypeReference(t.identifier(baseName), t.tsTypeParameterInstantiation(typeParams));
+        }
+    }
+    // Handle primitive types
+    switch (typeStr) {
+        case 'string':
+            return t.tsStringKeyword();
+        case 'number':
+            return t.tsNumberKeyword();
+        case 'boolean':
+            return t.tsBooleanKeyword();
+        case 'null':
+            return t.tsNullKeyword();
+        case 'unknown':
+            return t.tsUnknownKeyword();
+        default:
+            return t.tsTypeReference(t.identifier(typeStr));
+    }
+}
+/**
+ * Create an interface property signature
+ */
+function createPropertySignature(name, typeStr, optional) {
+    const prop = t.tsPropertySignature(t.identifier(name), t.tsTypeAnnotation(parseTypeString(typeStr)));
+    prop.optional = optional;
+    return prop;
+}
+/**
+ * Create an exported interface declaration
+ */
+function createExportedInterface(name, properties) {
+    const props = properties.map((p) => createPropertySignature(p.name, p.type, p.optional));
+    const body = t.tsInterfaceBody(props);
+    const interfaceDecl = t.tsInterfaceDeclaration(t.identifier(name), null, null, body);
+    return t.exportNamedDeclaration(interfaceDecl);
+}
+/**
+ * Create an exported type alias declaration
+ */
+function createExportedTypeAlias(name, typeStr) {
+    const typeAlias = t.tsTypeAliasDeclaration(t.identifier(name), null, parseTypeString(typeStr));
+    return t.exportNamedDeclaration(typeAlias);
+}
+/**
+ * Create a union type from string literals
+ */
+function createStringLiteralUnion(values) {
+    return t.tsUnionType(values.map((v) => t.tsLiteralType(t.stringLiteral(v))));
+}
+/**
+ * Add a section comment to the first statement in an array
+ */
+function addSectionComment(statements, sectionName) {
+    if (statements.length > 0) {
+        addLineComment(statements[0], `============ ${sectionName} ============`);
+    }
+}
 /** Configuration for all scalar filter types - matches PostGraphile's generated filters */
 const SCALAR_FILTER_CONFIGS = [
     {
@@ -154,13 +235,15 @@ function buildScalarFilterProperties(config) {
     return props;
 }
 /**
- * Add scalar filter types to source file using ts-morph
+ * Generate scalar filter type statements
  */
-function addScalarFilterTypes(sourceFile) {
-    addSectionComment(sourceFile, 'Scalar Filter Types');
+function generateScalarFilterTypes() {
+    const statements = [];
     for (const config of SCALAR_FILTER_CONFIGS) {
-        sourceFile.addInterface(createInterface(config.name, buildScalarFilterProperties(config)));
+        statements.push(createExportedInterface(config.name, buildScalarFilterProperties(config)));
     }
+    addSectionComment(statements, 'Scalar Filter Types');
+    return statements;
 }
 // ============================================================================
 // Enum Types Collector
@@ -189,19 +272,24 @@ function collectEnumTypesFromTables(tables, typeRegistry) {
     return enumTypes;
 }
 /**
- * Add enum types to source file
+ * Generate enum type statements
  */
-function addEnumTypes(sourceFile, typeRegistry, enumTypeNames) {
+function generateEnumTypes(typeRegistry, enumTypeNames) {
     if (enumTypeNames.size === 0)
-        return;
-    addSectionComment(sourceFile, 'Enum Types');
+        return [];
+    const statements = [];
     for (const typeName of Array.from(enumTypeNames).sort()) {
         const typeInfo = typeRegistry.get(typeName);
         if (!typeInfo || typeInfo.kind !== 'ENUM' || !typeInfo.enumValues)
             continue;
-        const values = typeInfo.enumValues.map((v) => `'${v}'`).join(' | ');
-        sourceFile.addTypeAlias(createTypeAlias(typeName, values));
+        const unionType = createStringLiteralUnion(typeInfo.enumValues);
+        const typeAlias = t.tsTypeAliasDeclaration(t.identifier(typeName), null, unionType);
+        statements.push(t.exportNamedDeclaration(typeAlias));
     }
+    if (statements.length > 0) {
+        addSectionComment(statements, 'Enum Types');
+    }
+    return statements;
 }
 // ============================================================================
 // Entity Types Generator (AST-based)
@@ -226,40 +314,47 @@ function buildEntityProperties(table) {
     return properties;
 }
 /**
- * Add entity type interface for a table
- */
-function addEntityType(sourceFile, table) {
-    const { typeName } = getTableNames(table);
-    sourceFile.addInterface(createInterface(typeName, buildEntityProperties(table)));
-}
-/**
- * Add all entity types
+ * Generate entity type statements
  */
-function addEntityTypes(sourceFile, tables) {
-    addSectionComment(sourceFile, 'Entity Types');
+function generateEntityTypes(tables) {
+    const statements = [];
     for (const table of tables) {
-        addEntityType(sourceFile, table);
+        const { typeName } = getTableNames(table);
+        statements.push(createExportedInterface(typeName, buildEntityProperties(table)));
     }
+    if (statements.length > 0) {
+        addSectionComment(statements, 'Entity Types');
+    }
+    return statements;
 }
 // ============================================================================
 // Relation Helper Types Generator (AST-based)
 // ============================================================================
 /**
- * Add relation helper types (ConnectionResult, PageInfo)
+ * Generate relation helper type statements (ConnectionResult, PageInfo)
  */
-function addRelationHelperTypes(sourceFile) {
-    addSectionComment(sourceFile, 'Relation Helper Types');
-    sourceFile.addInterface(createInterface('ConnectionResult<T>', [
-        { name: 'nodes', type: 'T[]', optional: false },
-        { name: 'totalCount', type: 'number', optional: false },
-        { name: 'pageInfo', type: 'PageInfo', optional: false },
-    ]));
-    sourceFile.addInterface(createInterface('PageInfo', [
+function generateRelationHelperTypes() {
+    const statements = [];
+    // ConnectionResult<T> interface with type parameter
+    const connectionResultProps = [
+        createPropertySignature('nodes', 'T[]', false),
+        createPropertySignature('totalCount', 'number', false),
+        createPropertySignature('pageInfo', 'PageInfo', false),
+    ];
+    const connectionResultBody = t.tsInterfaceBody(connectionResultProps);
+    const connectionResultDecl = t.tsInterfaceDeclaration(t.identifier('ConnectionResult'), t.tsTypeParameterDeclaration([
+        t.tsTypeParameter(null, null, 'T'),
+    ]), null, connectionResultBody);
+    statements.push(t.exportNamedDeclaration(connectionResultDecl));
+    // PageInfo interface
+    statements.push(createExportedInterface('PageInfo', [
         { name: 'hasNextPage', type: 'boolean', optional: false },
         { name: 'hasPreviousPage', type: 'boolean', optional: false },
         { name: 'startCursor', type: 'string | null', optional: true },
         { name: 'endCursor', type: 'string | null', optional: true },
     ]));
+    addSectionComment(statements, 'Relation Helper Types');
+    return statements;
 }
 // ============================================================================
 // Entity Relation Types Generator (AST-based)
@@ -332,44 +427,65 @@ function buildEntityRelationProperties(table, tableByName) {
     return properties;
 }
 /**
- * Add entity relation types
+ * Generate entity relation type statements
  */
-function addEntityRelationTypes(sourceFile, tables, tableByName) {
-    addSectionComment(sourceFile, 'Entity Relation Types');
+function generateEntityRelationTypes(tables, tableByName) {
+    const statements = [];
     for (const table of tables) {
         const { typeName } = getTableNames(table);
-        sourceFile.addInterface(createInterface(`${typeName}Relations`, buildEntityRelationProperties(table, tableByName)));
+        statements.push(createExportedInterface(`${typeName}Relations`, buildEntityRelationProperties(table, tableByName)));
     }
+    if (statements.length > 0) {
+        addSectionComment(statements, 'Entity Relation Types');
+    }
+    return statements;
 }
 /**
- * Add entity types with relations (intersection types)
+ * Generate entity types with relations (intersection types)
  */
-function addEntityWithRelations(sourceFile, tables) {
-    addSectionComment(sourceFile, 'Entity Types With Relations');
+function generateEntityWithRelations(tables) {
+    const statements = [];
     for (const table of tables) {
         const { typeName } = getTableNames(table);
-        sourceFile.addTypeAlias(createTypeAlias(`${typeName}WithRelations`, `${typeName} & ${typeName}Relations`));
+        statements.push(createExportedTypeAlias(`${typeName}WithRelations`, `${typeName} & ${typeName}Relations`));
+    }
+    if (statements.length > 0) {
+        addSectionComment(statements, 'Entity Types With Relations');
     }
+    return statements;
 }
 // ============================================================================
 // Entity Select Types Generator (AST-based)
 // ============================================================================
 /**
- * Build the type string for a Select type (as object type literal)
+ * Build the Select type as a TSTypeLiteral
  */
-function buildSelectTypeBody(table, tableByName) {
-    const lines = ['{'];
+function buildSelectTypeLiteral(table, tableByName) {
+    const members = [];
     // Add scalar fields
     for (const field of table.fields) {
         if (!isRelationField(field.name, table)) {
-            lines.push(`${field.name}?: boolean;`);
+            const prop = t.tsPropertySignature(t.identifier(field.name), t.tsTypeAnnotation(t.tsBooleanKeyword()));
+            prop.optional = true;
+            members.push(prop);
         }
     }
     // Add belongsTo relations
     for (const relation of table.relations.belongsTo) {
         if (relation.fieldName) {
             const relatedTypeName = getRelatedTypeName(relation.referencesTable, tableByName);
-            lines.push(`${relation.fieldName}?: boolean | { select?: ${relatedTypeName}Select };`);
+            const prop = t.tsPropertySignature(t.identifier(relation.fieldName), t.tsTypeAnnotation(t.tsUnionType([
+                t.tsBooleanKeyword(),
+                t.tsTypeLiteral([
+                    (() => {
+                        const selectProp = t.tsPropertySignature(t.identifier('select'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(`${relatedTypeName}Select`))));
+                        selectProp.optional = true;
+                        return selectProp;
+                    })(),
+                ]),
+            ])));
+            prop.optional = true;
+            members.push(prop);
         }
     }
     // Add hasMany relations
@@ -378,12 +494,33 @@ function buildSelectTypeBody(table, tableByName) {
             const relatedTypeName = getRelatedTypeName(relation.referencedByTable, tableByName);
             const filterName = getRelatedFilterName(relation.referencedByTable, tableByName);
             const orderByName = getRelatedOrderByName(relation.referencedByTable, tableByName);
-            lines.push(`${relation.fieldName}?: boolean | {`);
-            lines.push(`  select?: ${relatedTypeName}Select;`);
-            lines.push(`  first?: number;`);
-            lines.push(`  filter?: ${filterName};`);
-            lines.push(`  orderBy?: ${orderByName}[];`);
-            lines.push(`};`);
+            const prop = t.tsPropertySignature(t.identifier(relation.fieldName), t.tsTypeAnnotation(t.tsUnionType([
+                t.tsBooleanKeyword(),
+                t.tsTypeLiteral([
+                    (() => {
+                        const p = t.tsPropertySignature(t.identifier('select'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(`${relatedTypeName}Select`))));
+                        p.optional = true;
+                        return p;
+                    })(),
+                    (() => {
+                        const p = t.tsPropertySignature(t.identifier('first'), t.tsTypeAnnotation(t.tsNumberKeyword()));
+                        p.optional = true;
+                        return p;
+                    })(),
+                    (() => {
+                        const p = t.tsPropertySignature(t.identifier('filter'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(filterName))));
+                        p.optional = true;
+                        return p;
+                    })(),
+                    (() => {
+                        const p = t.tsPropertySignature(t.identifier('orderBy'), t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier(orderByName)))));
+                        p.optional = true;
+                        return p;
+                    })(),
+                ]),
+            ])));
+            prop.optional = true;
+            members.push(prop);
         }
     }
     // Add manyToMany relations
@@ -392,33 +529,69 @@ function buildSelectTypeBody(table, tableByName) {
             const relatedTypeName = getRelatedTypeName(relation.rightTable, tableByName);
             const filterName = getRelatedFilterName(relation.rightTable, tableByName);
             const orderByName = getRelatedOrderByName(relation.rightTable, tableByName);
-            lines.push(`${relation.fieldName}?: boolean | {`);
-            lines.push(`  select?: ${relatedTypeName}Select;`);
-            lines.push(`  first?: number;`);
-            lines.push(`  filter?: ${filterName};`);
-            lines.push(`  orderBy?: ${orderByName}[];`);
-            lines.push(`};`);
+            const prop = t.tsPropertySignature(t.identifier(relation.fieldName), t.tsTypeAnnotation(t.tsUnionType([
+                t.tsBooleanKeyword(),
+                t.tsTypeLiteral([
+                    (() => {
+                        const p = t.tsPropertySignature(t.identifier('select'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(`${relatedTypeName}Select`))));
+                        p.optional = true;
+                        return p;
+                    })(),
+                    (() => {
+                        const p = t.tsPropertySignature(t.identifier('first'), t.tsTypeAnnotation(t.tsNumberKeyword()));
+                        p.optional = true;
+                        return p;
+                    })(),
+                    (() => {
+                        const p = t.tsPropertySignature(t.identifier('filter'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(filterName))));
+                        p.optional = true;
+                        return p;
+                    })(),
+                    (() => {
+                        const p = t.tsPropertySignature(t.identifier('orderBy'), t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier(orderByName)))));
+                        p.optional = true;
+                        return p;
+                    })(),
+                ]),
+            ])));
+            prop.optional = true;
+            members.push(prop);
         }
     }
     // Add hasOne relations
     for (const relation of table.relations.hasOne) {
         if (relation.fieldName) {
             const relatedTypeName = getRelatedTypeName(relation.referencedByTable, tableByName);
-            lines.push(`${relation.fieldName}?: boolean | { select?: ${relatedTypeName}Select };`);
+            const prop = t.tsPropertySignature(t.identifier(relation.fieldName), t.tsTypeAnnotation(t.tsUnionType([
+                t.tsBooleanKeyword(),
+                t.tsTypeLiteral([
+                    (() => {
+                        const selectProp = t.tsPropertySignature(t.identifier('select'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(`${relatedTypeName}Select`))));
+                        selectProp.optional = true;
+                        return selectProp;
+                    })(),
+                ]),
+            ])));
+            prop.optional = true;
+            members.push(prop);
         }
     }
-    lines.push('}');
-    return lines.join('\n');
+    return t.tsTypeLiteral(members);
 }
 /**
- * Add entity Select types
+ * Generate entity Select type statements
  */
-function addEntitySelectTypes(sourceFile, tables, tableByName) {
-    addSectionComment(sourceFile, 'Entity Select Types');
+function generateEntitySelectTypes(tables, tableByName) {
+    const statements = [];
     for (const table of tables) {
         const { typeName } = getTableNames(table);
-        sourceFile.addTypeAlias(createTypeAlias(`${typeName}Select`, buildSelectTypeBody(table, tableByName)));
+        const typeAlias = t.tsTypeAliasDeclaration(t.identifier(`${typeName}Select`), null, buildSelectTypeLiteral(table, tableByName));
+        statements.push(t.exportNamedDeclaration(typeAlias));
+    }
+    if (statements.length > 0) {
+        addSectionComment(statements, 'Entity Select Types');
     }
+    return statements;
 }
 // ============================================================================
 // Table Filter Types Generator (AST-based)
@@ -449,14 +622,18 @@ function buildTableFilterProperties(table) {
     return properties;
 }
 /**
- * Add table filter types
+ * Generate table filter type statements
  */
-function addTableFilterTypes(sourceFile, tables) {
-    addSectionComment(sourceFile, 'Table Filter Types');
+function generateTableFilterTypes(tables) {
+    const statements = [];
     for (const table of tables) {
         const filterName = getFilterTypeName(table);
-        sourceFile.addInterface(createInterface(filterName, buildTableFilterProperties(table)));
+        statements.push(createExportedInterface(filterName, buildTableFilterProperties(table)));
     }
+    if (statements.length > 0) {
+        addSectionComment(statements, 'Table Filter Types');
+    }
+    return statements;
 }
 // ============================================================================
 // Condition Types Generator (AST-based)
@@ -482,22 +659,26 @@ function buildTableConditionProperties(table) {
     return properties;
 }
 /**
- * Add table condition types
+ * Generate table condition type statements
  */
-function addTableConditionTypes(sourceFile, tables) {
-    addSectionComment(sourceFile, 'Table Condition Types');
+function generateTableConditionTypes(tables) {
+    const statements = [];
     for (const table of tables) {
         const conditionName = getConditionTypeName(table);
-        sourceFile.addInterface(createInterface(conditionName, buildTableConditionProperties(table)));
+        statements.push(createExportedInterface(conditionName, buildTableConditionProperties(table)));
+    }
+    if (statements.length > 0) {
+        addSectionComment(statements, 'Table Condition Types');
     }
+    return statements;
 }
 // ============================================================================
 // OrderBy Types Generator (AST-based)
 // ============================================================================
 /**
- * Build OrderBy union type string
+ * Build OrderBy union type values
  */
-function buildOrderByUnion(table) {
+function buildOrderByValues(table) {
     const values = ['PRIMARY_KEY_ASC', 'PRIMARY_KEY_DESC', 'NATURAL'];
     for (const field of table.fields) {
         if (isRelationField(field.name, table))
@@ -506,19 +687,24 @@ function buildOrderByUnion(table) {
         values.push(`${upperSnake}_ASC`);
         values.push(`${upperSnake}_DESC`);
     }
-    return values.map((v) => `'${v}'`).join(' | ');
+    return values;
 }
 /**
- * Add OrderBy types
- * Uses inflection from table metadata for correct pluralization
+ * Generate OrderBy type statements
  */
-function addOrderByTypes(sourceFile, tables) {
-    addSectionComment(sourceFile, 'OrderBy Types');
+function generateOrderByTypes(tables) {
+    const statements = [];
     for (const table of tables) {
-        // Use getOrderByTypeName which respects table.inflection.orderByType
         const enumName = getOrderByTypeName(table);
-        sourceFile.addTypeAlias(createTypeAlias(enumName, buildOrderByUnion(table)));
+        const values = buildOrderByValues(table);
+        const unionType = createStringLiteralUnion(values);
+        const typeAlias = t.tsTypeAliasDeclaration(t.identifier(enumName), null, unionType);
+        statements.push(t.exportNamedDeclaration(typeAlias));
+    }
+    if (statements.length > 0) {
+        addSectionComment(statements, 'OrderBy Types');
     }
+    return statements;
 }
 // ============================================================================
 // CRUD Input Types Generator (AST-based)
@@ -541,27 +727,30 @@ function buildCreateDataFields(table) {
     return fields;
 }
 /**
- * Generate Create input interface as formatted string.
- *
- * ts-morph doesn't handle nested object types in interface properties well,
- * so we build this manually with pre-doubled indentation (4→2, 8→4) since
- * getMinimalFormattedOutput halves all indentation.
+ * Build Create input interface as AST
  */
 function buildCreateInputInterface(table) {
     const { typeName, singularName } = getTableNames(table);
     const fields = buildCreateDataFields(table);
-    const lines = [
-        `export interface Create${typeName}Input {`,
-        `    clientMutationId?: string;`,
-        `    ${singularName}: {`,
+    // Build the nested object type for the entity data
+    const nestedProps = fields.map((field) => {
+        const prop = t.tsPropertySignature(t.identifier(field.name), t.tsTypeAnnotation(parseTypeString(field.type)));
+        prop.optional = field.optional;
+        return prop;
+    });
+    const nestedObjectType = t.tsTypeLiteral(nestedProps);
+    // Build the main interface properties
+    const mainProps = [
+        (() => {
+            const prop = t.tsPropertySignature(t.identifier('clientMutationId'), t.tsTypeAnnotation(t.tsStringKeyword()));
+            prop.optional = true;
+            return prop;
+        })(),
+        t.tsPropertySignature(t.identifier(singularName), t.tsTypeAnnotation(nestedObjectType)),
     ];
-    for (const field of fields) {
-        const opt = field.optional ? '?' : '';
-        lines.push(`        ${field.name}${opt}: ${field.type};`);
-    }
-    lines.push('    };');
-    lines.push('}');
-    return lines.join('\n');
+    const body = t.tsInterfaceBody(mainProps);
+    const interfaceDecl = t.tsInterfaceDeclaration(t.identifier(`Create${typeName}Input`), null, null, body);
+    return t.exportNamedDeclaration(interfaceDecl);
 }
 /**
  * Build Patch type properties
@@ -584,35 +773,41 @@ function buildPatchProperties(table) {
     return properties;
 }
 /**
- * Add CRUD input types for a table
+ * Generate CRUD input type statements for a table
  */
-function addCrudInputTypes(sourceFile, table) {
+function generateCrudInputTypes(table) {
+    const statements = [];
     const { typeName } = getTableNames(table);
     const patchName = `${typeName}Patch`;
-    // Create input - build as raw statement due to nested object type formatting
-    sourceFile.addStatements(buildCreateInputInterface(table));
+    // Create input
+    statements.push(buildCreateInputInterface(table));
     // Patch interface
-    sourceFile.addInterface(createInterface(patchName, buildPatchProperties(table)));
+    statements.push(createExportedInterface(patchName, buildPatchProperties(table)));
     // Update input
-    sourceFile.addInterface(createInterface(`Update${typeName}Input`, [
+    statements.push(createExportedInterface(`Update${typeName}Input`, [
         { name: 'clientMutationId', type: 'string', optional: true },
         { name: 'id', type: 'string', optional: false },
         { name: 'patch', type: patchName, optional: false },
     ]));
     // Delete input
-    sourceFile.addInterface(createInterface(`Delete${typeName}Input`, [
+    statements.push(createExportedInterface(`Delete${typeName}Input`, [
         { name: 'clientMutationId', type: 'string', optional: true },
         { name: 'id', type: 'string', optional: false },
     ]));
+    return statements;
 }
 /**
- * Add all CRUD input types
+ * Generate all CRUD input type statements
  */
-function addAllCrudInputTypes(sourceFile, tables) {
-    addSectionComment(sourceFile, 'CRUD Input Types');
+function generateAllCrudInputTypes(tables) {
+    const statements = [];
     for (const table of tables) {
-        addCrudInputTypes(sourceFile, table);
+        statements.push(...generateCrudInputTypes(table));
+    }
+    if (statements.length > 0) {
+        addSectionComment(statements, 'CRUD Input Types');
     }
+    return statements;
 }
 // ============================================================================
 // Custom Input Types Generator (AST-based)
@@ -640,7 +835,7 @@ export function collectInputTypeNames(operations) {
 }
 /**
  * Build a set of exact table CRUD input type names to skip
- * These are generated by addAllCrudInputTypes, so we don't need to regenerate them
+ * These are generated by generateAllCrudInputTypes, so we don't need to regenerate them
  */
 function buildTableCrudTypeNames(tables) {
     const crudTypes = new Set();
@@ -655,10 +850,10 @@ function buildTableCrudTypeNames(tables) {
     return crudTypes;
 }
 /**
- * Add custom input types from TypeRegistry
+ * Generate custom input type statements from TypeRegistry
  */
-function addCustomInputTypes(sourceFile, typeRegistry, usedInputTypes, tableCrudTypes) {
-    addSectionComment(sourceFile, 'Custom Input Types (from schema)');
+function generateCustomInputTypes(typeRegistry, usedInputTypes, tableCrudTypes) {
+    const statements = [];
     const generatedTypes = new Set();
     const typesToGenerate = new Set(Array.from(usedInputTypes));
     // Filter out types we've already generated (exact matches for table CRUD types only)
@@ -681,8 +876,11 @@ function addCustomInputTypes(sourceFile, typeRegistry, usedInputTypes, tableCrud
         generatedTypes.add(typeName);
         const typeInfo = typeRegistry.get(typeName);
         if (!typeInfo) {
-            sourceFile.addStatements(`// Type '${typeName}' not found in schema`);
-            sourceFile.addTypeAlias(createTypeAlias(typeName, 'Record<string, unknown>'));
+            // Add comment for missing type
+            const commentStmt = t.emptyStatement();
+            addLineComment(commentStmt, ` Type '${typeName}' not found in schema`);
+            statements.push(commentStmt);
+            statements.push(createExportedTypeAlias(typeName, 'Record<string, unknown>'));
             continue;
         }
         if (typeInfo.kind === 'INPUT_OBJECT' && typeInfo.inputFields) {
@@ -699,17 +897,25 @@ function addCustomInputTypes(sourceFile, typeRegistry, usedInputTypes, tableCrud
                     typesToGenerate.add(baseType);
                 }
             }
-            sourceFile.addInterface(createInterface(typeName, properties));
+            statements.push(createExportedInterface(typeName, properties));
         }
         else if (typeInfo.kind === 'ENUM' && typeInfo.enumValues) {
-            const values = typeInfo.enumValues.map((v) => `'${v}'`).join(' | ');
-            sourceFile.addTypeAlias(createTypeAlias(typeName, values));
+            const unionType = createStringLiteralUnion(typeInfo.enumValues);
+            const typeAlias = t.tsTypeAliasDeclaration(t.identifier(typeName), null, unionType);
+            statements.push(t.exportNamedDeclaration(typeAlias));
         }
         else {
-            sourceFile.addStatements(`// Type '${typeName}' is ${typeInfo.kind}`);
-            sourceFile.addTypeAlias(createTypeAlias(typeName, 'unknown'));
+            // Add comment for unsupported type kind
+            const commentStmt = t.emptyStatement();
+            addLineComment(commentStmt, ` Type '${typeName}' is ${typeInfo.kind}`);
+            statements.push(commentStmt);
+            statements.push(createExportedTypeAlias(typeName, 'unknown'));
         }
     }
+    if (statements.length > 0) {
+        addSectionComment(statements, 'Custom Input Types (from schema)');
+    }
+    return statements;
 }
 // ============================================================================
 // Payload/Return Types Generator (AST-based)
@@ -729,10 +935,10 @@ export function collectPayloadTypeNames(operations) {
     return payloadTypes;
 }
 /**
- * Add payload/return types
+ * Generate payload/return type statements
  */
-function addPayloadTypes(sourceFile, typeRegistry, usedPayloadTypes, alreadyGeneratedTypes) {
-    addSectionComment(sourceFile, 'Payload/Return Types (for custom operations)');
+function generatePayloadTypes(typeRegistry, usedPayloadTypes, alreadyGeneratedTypes) {
+    const statements = [];
     const generatedTypes = new Set(alreadyGeneratedTypes);
     const typesToGenerate = new Set(Array.from(usedPayloadTypes));
     const skipTypes = new Set([
@@ -790,63 +996,77 @@ function addPayloadTypes(sourceFile, typeRegistry, usedPayloadTypes, alreadyGene
                 }
             }
         }
-        sourceFile.addInterface(createInterface(typeName, interfaceProps));
-        // Build Select type (no indentation - ts-morph adds it)
-        const selectLines = ['{'];
+        statements.push(createExportedInterface(typeName, interfaceProps));
+        // Build Select type
+        const selectMembers = [];
         for (const field of typeInfo.fields) {
             const baseType = getTypeBaseName(field.type);
             if (baseType === 'Query' || baseType === 'Mutation')
                 continue;
             const nestedType = baseType ? typeRegistry.get(baseType) : null;
+            let propType;
             if (nestedType?.kind === 'OBJECT') {
-                selectLines.push(`${field.name}?: boolean | { select?: ${baseType}Select };`);
+                propType = t.tsUnionType([
+                    t.tsBooleanKeyword(),
+                    t.tsTypeLiteral([
+                        (() => {
+                            const p = t.tsPropertySignature(t.identifier('select'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(`${baseType}Select`))));
+                            p.optional = true;
+                            return p;
+                        })(),
+                    ]),
+                ]);
             }
             else {
-                selectLines.push(`${field.name}?: boolean;`);
+                propType = t.tsBooleanKeyword();
             }
+            const prop = t.tsPropertySignature(t.identifier(field.name), t.tsTypeAnnotation(propType));
+            prop.optional = true;
+            selectMembers.push(prop);
         }
-        selectLines.push('}');
-        sourceFile.addTypeAlias(createTypeAlias(`${typeName}Select`, selectLines.join('\n')));
+        const selectTypeAlias = t.tsTypeAliasDeclaration(t.identifier(`${typeName}Select`), null, t.tsTypeLiteral(selectMembers));
+        statements.push(t.exportNamedDeclaration(selectTypeAlias));
+    }
+    if (statements.length > 0) {
+        addSectionComment(statements, 'Payload/Return Types (for custom operations)');
     }
+    return statements;
 }
 // ============================================================================
 // Main Generator (AST-based)
 // ============================================================================
 /**
- * Generate comprehensive input-types.ts file using ts-morph AST
+ * Generate comprehensive input-types.ts file using Babel AST
  */
 export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, usedPayloadTypes) {
-    const project = createProject();
-    const sourceFile = createSourceFile(project, 'input-types.ts');
-    // Add file header
-    sourceFile.insertText(0, createFileHeader('GraphQL types for ORM client') + '\n');
+    const statements = [];
     // 1. Scalar filter types
-    addScalarFilterTypes(sourceFile);
+    statements.push(...generateScalarFilterTypes());
     // 2. Enum types used by table fields
     if (tables && tables.length > 0) {
         const enumTypes = collectEnumTypesFromTables(tables, typeRegistry);
-        addEnumTypes(sourceFile, typeRegistry, enumTypes);
+        statements.push(...generateEnumTypes(typeRegistry, enumTypes));
     }
     // 3. Entity and relation types (if tables provided)
     if (tables && tables.length > 0) {
         const tableByName = new Map(tables.map((table) => [table.name, table]));
-        addEntityTypes(sourceFile, tables);
-        addRelationHelperTypes(sourceFile);
-        addEntityRelationTypes(sourceFile, tables, tableByName);
-        addEntityWithRelations(sourceFile, tables);
-        addEntitySelectTypes(sourceFile, tables, tableByName);
+        statements.push(...generateEntityTypes(tables));
+        statements.push(...generateRelationHelperTypes());
+        statements.push(...generateEntityRelationTypes(tables, tableByName));
+        statements.push(...generateEntityWithRelations(tables));
+        statements.push(...generateEntitySelectTypes(tables, tableByName));
         // 4. Table filter types
-        addTableFilterTypes(sourceFile, tables);
+        statements.push(...generateTableFilterTypes(tables));
         // 4b. Table condition types (simple equality filter)
-        addTableConditionTypes(sourceFile, tables);
+        statements.push(...generateTableConditionTypes(tables));
         // 5. OrderBy types
-        addOrderByTypes(sourceFile, tables);
+        statements.push(...generateOrderByTypes(tables));
         // 6. CRUD input types
-        addAllCrudInputTypes(sourceFile, tables);
+        statements.push(...generateAllCrudInputTypes(tables));
     }
     // 7. Custom input types from TypeRegistry
     const tableCrudTypes = tables ? buildTableCrudTypeNames(tables) : undefined;
-    addCustomInputTypes(sourceFile, typeRegistry, usedInputTypes, tableCrudTypes);
+    statements.push(...generateCustomInputTypes(typeRegistry, usedInputTypes, tableCrudTypes));
     // 8. Payload/return types for custom operations
     if (usedPayloadTypes && usedPayloadTypes.size > 0) {
         const alreadyGeneratedTypes = new Set();
@@ -856,10 +1076,13 @@ export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, use
                 alreadyGeneratedTypes.add(typeName);
             }
         }
-        addPayloadTypes(sourceFile, typeRegistry, usedPayloadTypes, alreadyGeneratedTypes);
+        statements.push(...generatePayloadTypes(typeRegistry, usedPayloadTypes, alreadyGeneratedTypes));
     }
+    // Generate code with file header
+    const header = getGeneratedFileHeader('GraphQL types for ORM client');
+    const code = generateCode(statements);
     return {
         fileName: 'input-types.ts',
-        content: getMinimalFormattedOutput(sourceFile),
+        content: header + '\n' + code,
     };
 }