@constructive-io/graphql-codegen 2.23.3 → 2.24.0

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

@@ -1,9 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectInputTypeNames = collectInputTypeNames;
 exports.collectPayloadTypeNames = collectPayloadTypeNames;
 exports.generateInputTypesFile = generateInputTypesFile;
-const ts_ast_1 = require("../ts-ast");
+const t = __importStar(require("@babel/types"));
+const babel_ast_1 = require("../babel-ast");
 const utils_1 = require("../utils");
 const inflekt_1 = require("inflekt");
 const type_resolver_1 = require("../type-resolver");
@@ -62,6 +96,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) {
+        (0, babel_ast_1.addLineComment)(statements[0], `============ ${sectionName} ============`);
+    }
+}
 /** Configuration for all scalar filter types - matches PostGraphile's generated filters */
 const SCALAR_FILTER_CONFIGS = [
     {
@@ -159,13 +273,15 @@ function buildScalarFilterProperties(config) {
     return props;
 }
 /**
- * Add scalar filter types to source file using ts-morph
+ * Generate scalar filter type statements
  */
-function addScalarFilterTypes(sourceFile) {
-    (0, ts_ast_1.addSectionComment)(sourceFile, 'Scalar Filter Types');
+function generateScalarFilterTypes() {
+    const statements = [];
     for (const config of SCALAR_FILTER_CONFIGS) {
-        sourceFile.addInterface((0, ts_ast_1.createInterface)(config.name, buildScalarFilterProperties(config)));
+        statements.push(createExportedInterface(config.name, buildScalarFilterProperties(config)));
     }
+    addSectionComment(statements, 'Scalar Filter Types');
+    return statements;
 }
 // ============================================================================
 // Enum Types Collector
@@ -194,19 +310,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;
-    (0, ts_ast_1.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((0, ts_ast_1.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)
@@ -231,40 +352,47 @@ function buildEntityProperties(table) {
     return properties;
 }
 /**
- * Add entity type interface for a table
- */
-function addEntityType(sourceFile, table) {
-    const { typeName } = (0, utils_1.getTableNames)(table);
-    sourceFile.addInterface((0, ts_ast_1.createInterface)(typeName, buildEntityProperties(table)));
-}
-/**
- * Add all entity types
+ * Generate entity type statements
  */
-function addEntityTypes(sourceFile, tables) {
-    (0, ts_ast_1.addSectionComment)(sourceFile, 'Entity Types');
+function generateEntityTypes(tables) {
+    const statements = [];
     for (const table of tables) {
-        addEntityType(sourceFile, table);
+        const { typeName } = (0, utils_1.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) {
-    (0, ts_ast_1.addSectionComment)(sourceFile, 'Relation Helper Types');
-    sourceFile.addInterface((0, ts_ast_1.createInterface)('ConnectionResult<T>', [
-        { name: 'nodes', type: 'T[]', optional: false },
-        { name: 'totalCount', type: 'number', optional: false },
-        { name: 'pageInfo', type: 'PageInfo', optional: false },
-    ]));
-    sourceFile.addInterface((0, ts_ast_1.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)
@@ -337,44 +465,65 @@ function buildEntityRelationProperties(table, tableByName) {
     return properties;
 }
 /**
- * Add entity relation types
+ * Generate entity relation type statements
  */
-function addEntityRelationTypes(sourceFile, tables, tableByName) {
-    (0, ts_ast_1.addSectionComment)(sourceFile, 'Entity Relation Types');
+function generateEntityRelationTypes(tables, tableByName) {
+    const statements = [];
     for (const table of tables) {
         const { typeName } = (0, utils_1.getTableNames)(table);
-        sourceFile.addInterface((0, ts_ast_1.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) {
-    (0, ts_ast_1.addSectionComment)(sourceFile, 'Entity Types With Relations');
+function generateEntityWithRelations(tables) {
+    const statements = [];
     for (const table of tables) {
         const { typeName } = (0, utils_1.getTableNames)(table);
-        sourceFile.addTypeAlias((0, ts_ast_1.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 (!(0, utils_1.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
@@ -383,12 +532,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
@@ -397,33 +567,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) {
-    (0, ts_ast_1.addSectionComment)(sourceFile, 'Entity Select Types');
+function generateEntitySelectTypes(tables, tableByName) {
+    const statements = [];
     for (const table of tables) {
         const { typeName } = (0, utils_1.getTableNames)(table);
-        sourceFile.addTypeAlias((0, ts_ast_1.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)
@@ -454,14 +660,18 @@ function buildTableFilterProperties(table) {
     return properties;
 }
 /**
- * Add table filter types
+ * Generate table filter type statements
  */
-function addTableFilterTypes(sourceFile, tables) {
-    (0, ts_ast_1.addSectionComment)(sourceFile, 'Table Filter Types');
+function generateTableFilterTypes(tables) {
+    const statements = [];
     for (const table of tables) {
         const filterName = (0, utils_1.getFilterTypeName)(table);
-        sourceFile.addInterface((0, ts_ast_1.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)
@@ -487,22 +697,26 @@ function buildTableConditionProperties(table) {
     return properties;
 }
 /**
- * Add table condition types
+ * Generate table condition type statements
  */
-function addTableConditionTypes(sourceFile, tables) {
-    (0, ts_ast_1.addSectionComment)(sourceFile, 'Table Condition Types');
+function generateTableConditionTypes(tables) {
+    const statements = [];
     for (const table of tables) {
         const conditionName = (0, utils_1.getConditionTypeName)(table);
-        sourceFile.addInterface((0, ts_ast_1.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 ((0, utils_1.isRelationField)(field.name, table))
@@ -511,19 +725,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) {
-    (0, ts_ast_1.addSectionComment)(sourceFile, 'OrderBy Types');
+function generateOrderByTypes(tables) {
+    const statements = [];
     for (const table of tables) {
-        // Use getOrderByTypeName which respects table.inflection.orderByType
         const enumName = (0, utils_1.getOrderByTypeName)(table);
-        sourceFile.addTypeAlias((0, ts_ast_1.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)
@@ -546,27 +765,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 } = (0, utils_1.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
@@ -589,35 +811,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 } = (0, utils_1.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((0, ts_ast_1.createInterface)(patchName, buildPatchProperties(table)));
+    statements.push(createExportedInterface(patchName, buildPatchProperties(table)));
     // Update input
-    sourceFile.addInterface((0, ts_ast_1.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((0, ts_ast_1.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) {
-    (0, ts_ast_1.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)
@@ -645,7 +873,7 @@ 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();
@@ -660,10 +888,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) {
-    (0, ts_ast_1.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)
@@ -686,8 +914,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((0, ts_ast_1.createTypeAlias)(typeName, 'Record<string, unknown>'));
+            // Add comment for missing type
+            const commentStmt = t.emptyStatement();
+            (0, babel_ast_1.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) {
@@ -704,17 +935,25 @@ function addCustomInputTypes(sourceFile, typeRegistry, usedInputTypes, tableCrud
                     typesToGenerate.add(baseType);
                 }
             }
-            sourceFile.addInterface((0, ts_ast_1.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((0, ts_ast_1.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((0, ts_ast_1.createTypeAlias)(typeName, 'unknown'));
+            // Add comment for unsupported type kind
+            const commentStmt = t.emptyStatement();
+            (0, babel_ast_1.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)
@@ -734,10 +973,10 @@ function collectPayloadTypeNames(operations) {
     return payloadTypes;
 }
 /**
- * Add payload/return types
+ * Generate payload/return type statements
  */
-function addPayloadTypes(sourceFile, typeRegistry, usedPayloadTypes, alreadyGeneratedTypes) {
-    (0, ts_ast_1.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([
@@ -795,63 +1034,77 @@ function addPayloadTypes(sourceFile, typeRegistry, usedPayloadTypes, alreadyGene
                 }
             }
         }
-        sourceFile.addInterface((0, ts_ast_1.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 = (0, type_resolver_1.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((0, ts_ast_1.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
  */
 function generateInputTypesFile(typeRegistry, usedInputTypes, tables, usedPayloadTypes) {
-    const project = (0, ts_ast_1.createProject)();
-    const sourceFile = (0, ts_ast_1.createSourceFile)(project, 'input-types.ts');
-    // Add file header
-    sourceFile.insertText(0, (0, ts_ast_1.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();
@@ -861,10 +1114,13 @@ function generateInputTypesFile(typeRegistry, usedInputTypes, tables, usedPayloa
                 alreadyGeneratedTypes.add(typeName);
             }
         }
-        addPayloadTypes(sourceFile, typeRegistry, usedPayloadTypes, alreadyGeneratedTypes);
+        statements.push(...generatePayloadTypes(typeRegistry, usedPayloadTypes, alreadyGeneratedTypes));
     }
+    // Generate code with file header
+    const header = (0, utils_1.getGeneratedFileHeader)('GraphQL types for ORM client');
+    const code = (0, babel_ast_1.generateCode)(statements);
     return {
         fileName: 'input-types.ts',
-        content: (0, ts_ast_1.getMinimalFormattedOutput)(sourceFile),
+        content: header + '\n' + code,
     };
 }