@constructive-io/graphql-codegen 2.23.3 → 2.24.0

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

@@ -1,18 +1,46 @@
 "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.generateSchemaTypesFile = generateSchemaTypesFile;
-const ts_ast_1 = require("./ts-ast");
+const t = __importStar(require("@babel/types"));
+const babel_ast_1 = require("./babel-ast");
 const type_resolver_1 = require("./type-resolver");
 const scalars_1 = require("./scalars");
-// ============================================================================
-// Constants
-// ============================================================================
-/**
- * Types that should not be generated (scalars, built-ins, types generated elsewhere)
- */
+const utils_1 = require("./utils");
 const SKIP_TYPES = new Set([
     ...scalars_1.SCALAR_NAMES,
-    // GraphQL built-ins
     'Query',
     'Mutation',
     'Subscription',
@@ -22,27 +50,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)
     ...scalars_1.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) {
@@ -56,48 +66,26 @@ function typeRefToTs(typeRef) {
         }
         return 'unknown[]';
     }
-    // Scalar or named type
     const name = typeRef.name ?? 'unknown';
     return (0, scalars_1.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();
-    (0, ts_ast_1.addSectionComment)(sourceFile, 'Enum Types');
     for (const [typeName, typeInfo] of typeRegistry) {
         if (typeInfo.kind !== 'ENUM')
             continue;
@@ -105,23 +93,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((0, ts_ast_1.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;
@@ -131,10 +113,6 @@ function addInputObjectTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGe
             continue;
         typesToGenerate.add(typeName);
     }
-    if (typesToGenerate.size === 0)
-        return generatedTypes;
-    (0, ts_ast_1.addSectionComment)(sourceFile, 'Input Object Types');
-    // Process all types - no artificial limit
     while (typesToGenerate.size > 0) {
         const typeNameResult = typesToGenerate.values().next();
         if (typeNameResult.done)
@@ -147,18 +125,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 = (0, type_resolver_1.getTypeBaseName)(field.type);
                 if (baseType &&
                     !generatedTypes.has(baseType) &&
@@ -169,25 +143,15 @@ function addInputObjectTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGe
                     }
                 }
             }
-            sourceFile.addInterface((0, ts_ast_1.createInterface)(typeName, properties));
-        }
-        else {
-            // Empty input object
-            sourceFile.addInterface((0, ts_ast_1.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;
@@ -195,32 +159,17 @@ function addUnionTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGenerate
             continue;
         if (generatedTypes.has(typeName))
             continue;
-        unionTypesToGenerate.add(typeName);
-    }
-    if (unionTypesToGenerate.size === 0)
-        return generatedTypes;
-    (0, ts_ast_1.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((0, ts_ast_1.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) => {
@@ -242,30 +191,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 };
-    }
-    (0, ts_ast_1.addSectionComment)(sourceFile, 'Payload/Return Object Types');
-    // Process all types - no artificial limit
     while (typesToGenerate.size > 0) {
         const typeNameResult = typesToGenerate.values().next();
         if (typeNameResult.done)
@@ -278,26 +213,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 = (0, type_resolver_1.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)) {
@@ -307,59 +237,41 @@ function addPayloadObjectTypes(sourceFile, typeRegistry, tableTypeNames, already
                     }
                 }
             }
-            sourceFile.addInterface((0, ts_ast_1.createInterface)(typeName, properties));
-        }
-        else {
-            // Empty payload object
-            sourceFile.addInterface((0, ts_ast_1.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.
- */
 function generateSchemaTypesFile(options) {
     const { typeRegistry, tableTypeNames } = options;
-    const project = (0, ts_ast_1.createProject)();
-    const sourceFile = (0, ts_ast_1.createSourceFile)(project, 'schema-types.ts');
-    // Add file header
-    sourceFile.insertText(0, (0, ts_ast_1.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(scalars_1.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 = (0, babel_ast_1.generateCode)(allStatements);
+    const content = (0, utils_1.getGeneratedFileHeader)('GraphQL schema types for custom operations') + '\n\n' + code;
     return {
         fileName: 'schema-types.ts',
-        content: (0, ts_ast_1.getMinimalFormattedOutput)(sourceFile),
-        generatedEnums: Array.from(enumTypes).sort(),
+        content,
+        generatedEnums: Array.from(enumResult.generatedTypes).sort(),
         referencedTableTypes,
     };
 }

package/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/cli/codegen/type-resolver.js

@@ -8,10 +8,6 @@ exports.isTypeRequired = isTypeRequired;
 exports.isTypeList = isTypeList;
 exports.getTypeBaseName = getTypeBaseName;
 exports.getBaseTypeKind = getBaseTypeKind;
-exports.argumentToInterfaceProperty = argumentToInterfaceProperty;
-exports.fieldToInterfaceProperty = fieldToInterfaceProperty;
-exports.argumentsToInterfaceProperties = argumentsToInterfaceProperties;
-exports.fieldsToInterfaceProperties = fieldsToInterfaceProperties;
 exports.shouldSkipField = shouldSkipField;
 exports.getSelectableFields = getSelectableFields;
 exports.operationNameToPascal = operationNameToPascal;
@@ -184,55 +180,6 @@ 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
- */
-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
- */
-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
- */
-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
- */
-function fieldsToInterfaceProperties(fields, tracker) {
-    return fields.map((field) => fieldToInterfaceProperty(field, tracker));
-}
-// ============================================================================
 // Type Filtering
 // ============================================================================
 /**

package/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/cli/codegen/types.js

@@ -1,7 +1,41 @@
 "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.generateTypesFile = generateTypesFile;
-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");
 /** All filter type configurations - scalar and list filters */
 const FILTER_CONFIGS = [
@@ -67,16 +101,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
  */
 function generateTypesFile(tables, options = {}) {
     const { enumsFromSchemaTypes = [] } = options;
     const enumSet = new Set(enumsFromSchemaTypes);
-    const project = (0, ts_ast_1.createProject)();
-    const sourceFile = (0, ts_ast_1.createSourceFile)(project, 'types.ts');
-    // Add file header
-    sourceFile.insertText(0, (0, ts_ast_1.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) {
@@ -91,16 +151,13 @@ function generateTypesFile(tables, options = {}) {
     }
     // Add import for enum types from schema-types if any are used
     if (usedEnums.size > 0) {
-        sourceFile.addImportDeclaration((0, ts_ast_1.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 = (0, utils_1.getScalarFields)(table);
@@ -108,15 +165,13 @@ function generateTypesFile(tables, options = {}) {
             name: field.name,
             type: `${(0, utils_1.fieldTypeToTs)(field.type)} | null`,
         }));
-        sourceFile.addInterface((0, ts_ast_1.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((0, ts_ast_1.createInterface)(name, buildFilterProperties(tsType, operators)));
+        statements.push(createInterfaceDeclaration(name, buildFilterProperties(tsType, operators)));
     }
-    return (0, ts_ast_1.getFormattedOutput)(sourceFile);
+    const header = (0, utils_1.getGeneratedFileHeader)('Entity types and filter types');
+    const code = (0, babel_ast_1.generateCode)(statements);
+    return header + '\n' + code;
 }