@constructive-io/graphql-codegen 2.20.1 → 2.22.0

package/cli/codegen/index.js

@@ -5,11 +5,13 @@ exports.generateAllFiles = generateAllFiles;
 exports.generate = generate;
 const client_1 = require("./client");
 const types_1 = require("./types");
+const schema_types_generator_1 = require("./schema-types-generator");
 const queries_1 = require("./queries");
 const mutations_1 = require("./mutations");
 const custom_queries_1 = require("./custom-queries");
 const custom_mutations_1 = require("./custom-mutations");
 const barrel_1 = require("./barrel");
+const utils_1 = require("./utils");
 // ============================================================================
 // Main orchestrator
 // ============================================================================
@@ -28,25 +30,47 @@ function generate(options) {
     // Extract codegen options
     const maxDepth = config.codegen.maxFieldDepth;
     const skipQueryField = config.codegen.skipQueryField;
+    const reactQueryEnabled = config.reactQuery.enabled;
     // 1. Generate client.ts
     files.push({
         path: 'client.ts',
         content: (0, client_1.generateClientFile)(),
     });
-    // 2. Generate types.ts
+    // Collect table type names for import path resolution
+    const tableTypeNames = new Set(tables.map((t) => (0, utils_1.getTableNames)(t).typeName));
+    // 2. Generate schema-types.ts for custom operations (if any)
+    // NOTE: This must come BEFORE types.ts so that types.ts can import enum types
+    let hasSchemaTypes = false;
+    let generatedEnumNames = [];
+    if (customOperations && customOperations.typeRegistry) {
+        const schemaTypesResult = (0, schema_types_generator_1.generateSchemaTypesFile)({
+            typeRegistry: customOperations.typeRegistry,
+            tableTypeNames,
+        });
+        // Only include if there's meaningful content
+        if (schemaTypesResult.content.split('\n').length > 10) {
+            files.push({
+                path: 'schema-types.ts',
+                content: schemaTypesResult.content,
+            });
+            hasSchemaTypes = true;
+            generatedEnumNames = schemaTypesResult.generatedEnums || [];
+        }
+    }
+    // 3. Generate types.ts (can now import enums from schema-types)
     files.push({
         path: 'types.ts',
-        content: (0, types_1.generateTypesFile)(tables),
+        content: (0, types_1.generateTypesFile)(tables, { enumsFromSchemaTypes: generatedEnumNames }),
     });
-    // 3. Generate table-based query hooks (queries/*.ts)
-    const queryHooks = (0, queries_1.generateAllQueryHooks)(tables);
+    // 4. Generate table-based query hooks (queries/*.ts)
+    const queryHooks = (0, queries_1.generateAllQueryHooks)(tables, { reactQueryEnabled });
     for (const hook of queryHooks) {
         files.push({
             path: `queries/${hook.fileName}`,
             content: hook.content,
         });
     }
-    // 4. Generate custom query hooks if available
+    // 5. Generate custom query hooks if available
     let customQueryHooks = [];
     if (customOperations && customOperations.queries.length > 0) {
         customQueryHooks = (0, custom_queries_1.generateAllCustomQueryHooks)({
@@ -54,6 +78,8 @@ function generate(options) {
             typeRegistry: customOperations.typeRegistry,
             maxDepth,
             skipQueryField,
+            reactQueryEnabled,
+            tableTypeNames,
         });
         for (const hook of customQueryHooks) {
             files.push({
@@ -70,7 +96,10 @@ function generate(options) {
             : (0, barrel_1.generateQueriesBarrel)(tables),
     });
     // 6. Generate table-based mutation hooks (mutations/*.ts)
-    const mutationHooks = (0, mutations_1.generateAllMutationHooks)(tables);
+    const mutationHooks = (0, mutations_1.generateAllMutationHooks)(tables, {
+        reactQueryEnabled,
+        enumsFromSchemaTypes: generatedEnumNames,
+    });
     for (const hook of mutationHooks) {
         files.push({
             path: `mutations/${hook.fileName}`,
@@ -85,6 +114,8 @@ function generate(options) {
             typeRegistry: customOperations.typeRegistry,
             maxDepth,
             skipQueryField,
+            reactQueryEnabled,
+            tableTypeNames,
         });
         for (const hook of customMutationHooks) {
             files.push({
@@ -100,10 +131,10 @@ function generate(options) {
             ? (0, barrel_1.generateCustomMutationsBarrel)(tables, customMutationHooks.map((h) => h.operationName))
             : (0, barrel_1.generateMutationsBarrel)(tables),
     });
-    // 9. Generate main index.ts barrel
+    // 9. Generate main index.ts barrel (with schema-types if present)
     files.push({
         path: 'index.ts',
-        content: (0, barrel_1.generateMainBarrel)(tables),
+        content: (0, barrel_1.generateMainBarrel)(tables, hasSchemaTypes),
     });
     return {
         files,

package/cli/codegen/mutations.d.ts

@@ -12,19 +12,29 @@ export interface GeneratedMutationFile {
     fileName: string;
     content: string;
 }
+export interface MutationGeneratorOptions {
+    /** Whether to generate React Query hooks (default: true for backwards compatibility) */
+    reactQueryEnabled?: boolean;
+    /** Enum type names that are available from schema-types.ts */
+    enumsFromSchemaTypes?: string[];
+}
 /**
  * Generate create mutation hook file content using AST
+ * When reactQueryEnabled is false, returns null since mutations require React Query
  */
-export declare function generateCreateMutationHook(table: CleanTable): GeneratedMutationFile;
+export declare function generateCreateMutationHook(table: CleanTable, options?: MutationGeneratorOptions): GeneratedMutationFile | null;
 /**
  * Generate update mutation hook file content using AST
+ * When reactQueryEnabled is false, returns null since mutations require React Query
  */
-export declare function generateUpdateMutationHook(table: CleanTable): GeneratedMutationFile | null;
+export declare function generateUpdateMutationHook(table: CleanTable, options?: MutationGeneratorOptions): GeneratedMutationFile | null;
 /**
  * Generate delete mutation hook file content using AST
+ * When reactQueryEnabled is false, returns null since mutations require React Query
  */
-export declare function generateDeleteMutationHook(table: CleanTable): GeneratedMutationFile | null;
+export declare function generateDeleteMutationHook(table: CleanTable, options?: MutationGeneratorOptions): GeneratedMutationFile | null;
 /**
  * Generate all mutation hook files for all tables
+ * When reactQueryEnabled is false, returns empty array since mutations require React Query
  */
-export declare function generateAllMutationHooks(tables: CleanTable[]): GeneratedMutationFile[];
+export declare function generateAllMutationHooks(tables: CleanTable[], options?: MutationGeneratorOptions): GeneratedMutationFile[];

package/cli/codegen/mutations.js

@@ -7,26 +7,61 @@ exports.generateAllMutationHooks = generateAllMutationHooks;
 const ts_ast_1 = require("./ts-ast");
 const gql_ast_1 = require("./gql-ast");
 const utils_1 = require("./utils");
+/**
+ * Check if a field is auto-generated and should be excluded from create inputs
+ * Uses primary key from constraints and common timestamp patterns
+ */
+function isAutoGeneratedField(fieldName, pkFieldNames) {
+    const name = fieldName.toLowerCase();
+    // Exclude primary key fields (from constraints)
+    if (pkFieldNames.has(fieldName))
+        return true;
+    // Exclude common timestamp patterns (case-insensitive)
+    // These are typically auto-set by database triggers or defaults
+    const timestampPatterns = [
+        'createdat', 'created_at', 'createddate', 'created_date',
+        'updatedat', 'updated_at', 'updateddate', 'updated_date',
+        'deletedat', 'deleted_at', // soft delete timestamps
+    ];
+    return timestampPatterns.includes(name);
+}
 // ============================================================================
 // Create mutation hook generator
 // ============================================================================
 /**
  * Generate create mutation hook file content using AST
+ * When reactQueryEnabled is false, returns null since mutations require React Query
  */
-function generateCreateMutationHook(table) {
+function generateCreateMutationHook(table, options = {}) {
+    const { reactQueryEnabled = true, enumsFromSchemaTypes = [] } = options;
+    // Mutations require React Query - skip generation when disabled
+    if (!reactQueryEnabled) {
+        return null;
+    }
+    const enumSet = new Set(enumsFromSchemaTypes);
     const project = (0, ts_ast_1.createProject)();
     const { typeName, singularName } = (0, utils_1.getTableNames)(table);
     const hookName = (0, utils_1.getCreateMutationHookName)(table);
     const mutationName = (0, utils_1.getCreateMutationName)(table);
     const scalarFields = (0, utils_1.getScalarFields)(table);
+    // Get primary key field names dynamically from table constraints
+    const pkFieldNames = new Set((0, utils_1.getPrimaryKeyInfo)(table).map(pk => pk.name));
+    // Collect which enums are used by this table's fields
+    const usedEnums = new Set();
+    for (const field of scalarFields) {
+        const cleanType = field.type.gqlType.replace(/!/g, '');
+        if (enumSet.has(cleanType)) {
+            usedEnums.add(cleanType);
+        }
+    }
     // Generate GraphQL document via AST
     const mutationAST = (0, gql_ast_1.buildCreateMutationAST)({ table });
     const mutationDocument = (0, gql_ast_1.printGraphQL)(mutationAST);
     const sourceFile = (0, ts_ast_1.createSourceFile)(project, (0, utils_1.getCreateMutationFileName)(table));
     // Add file header
     sourceFile.insertText(0, (0, ts_ast_1.createFileHeader)(`Create mutation hook for ${typeName}`) + '\n\n');
-    // Add imports
-    sourceFile.addImportDeclarations([
+    // Build import declarations
+    const imports = [
         (0, ts_ast_1.createImport)({
             moduleSpecifier: '@tanstack/react-query',
             namedImports: ['useMutation', 'useQueryClient'],
@@ -40,7 +75,16 @@ function generateCreateMutationHook(table) {
             moduleSpecifier: '../types',
             typeOnlyNamedImports: [typeName],
         }),
-    ]);
+    ];
+    // Add import for enum types from schema-types if any are used
+    if (usedEnums.size > 0) {
+        imports.push((0, ts_ast_1.createImport)({
+            moduleSpecifier: '../schema-types',
+            typeOnlyNamedImports: Array.from(usedEnums).sort(),
+        }));
+    }
+    // Add imports
+    sourceFile.addImportDeclarations(imports);
     // Re-export entity type
     sourceFile.addStatements(`\n// Re-export entity type for convenience\nexport type { ${typeName} };\n`);
     // Add section comment
@@ -54,11 +98,9 @@ function generateCreateMutationHook(table) {
     sourceFile.addStatements('// Types');
     sourceFile.addStatements('// ============================================================================\n');
     // Generate CreateInput type - exclude auto-generated fields
+    // Note: Not exported to avoid conflicts with schema-types
     const inputFields = scalarFields
-        .filter((f) => {
-        const name = f.name.toLowerCase();
-        return !['id', 'createdat', 'updatedat', 'created_at', 'updated_at'].includes(name);
-    })
+        .filter((f) => !isAutoGeneratedField(f.name, pkFieldNames))
         .map((f) => ({
         name: f.name,
         type: `${(0, utils_1.fieldTypeToTs)(f.type)} | null`,
@@ -66,6 +108,7 @@ function generateCreateMutationHook(table) {
     }));
     sourceFile.addInterface((0, ts_ast_1.createInterface)(`${typeName}CreateInput`, inputFields, {
         docs: [`Input type for creating a ${typeName}`],
+        isExported: false,
     }));
     // Variables interface
     sourceFile.addInterface((0, ts_ast_1.createInterface)(`${(0, utils_1.ucFirst)(mutationName)}MutationVariables`, [
@@ -143,25 +186,44 @@ mutate({
 // ============================================================================
 /**
  * Generate update mutation hook file content using AST
+ * When reactQueryEnabled is false, returns null since mutations require React Query
  */
-function generateUpdateMutationHook(table) {
+function generateUpdateMutationHook(table, options = {}) {
+    const { reactQueryEnabled = true, enumsFromSchemaTypes = [] } = options;
+    // Mutations require React Query - skip generation when disabled
+    if (!reactQueryEnabled) {
+        return null;
+    }
     // Check if update mutation exists
     if (table.query?.update === null) {
         return null;
     }
+    const enumSet = new Set(enumsFromSchemaTypes);
     const project = (0, ts_ast_1.createProject)();
     const { typeName, singularName } = (0, utils_1.getTableNames)(table);
     const hookName = (0, utils_1.getUpdateMutationHookName)(table);
     const mutationName = (0, utils_1.getUpdateMutationName)(table);
     const scalarFields = (0, utils_1.getScalarFields)(table);
+    // Get primary key info dynamically from table constraints
+    const pkFields = (0, utils_1.getPrimaryKeyInfo)(table);
+    const pkField = pkFields[0]; // Use first PK field
+    const pkFieldNames = new Set(pkFields.map(pk => pk.name));
+    // Collect which enums are used by this table's fields
+    const usedEnums = new Set();
+    for (const field of scalarFields) {
+        const cleanType = field.type.gqlType.replace(/!/g, '');
+        if (enumSet.has(cleanType)) {
+            usedEnums.add(cleanType);
+        }
+    }
     // Generate GraphQL document via AST
     const mutationAST = (0, gql_ast_1.buildUpdateMutationAST)({ table });
     const mutationDocument = (0, gql_ast_1.printGraphQL)(mutationAST);
     const sourceFile = (0, ts_ast_1.createSourceFile)(project, (0, utils_1.getUpdateMutationFileName)(table));
     // Add file header
     sourceFile.insertText(0, (0, ts_ast_1.createFileHeader)(`Update mutation hook for ${typeName}`) + '\n\n');
-    // Add imports
-    sourceFile.addImportDeclarations([
+    // Build import declarations
+    const imports = [
         (0, ts_ast_1.createImport)({
             moduleSpecifier: '@tanstack/react-query',
             namedImports: ['useMutation', 'useQueryClient'],
@@ -175,7 +237,16 @@ function generateUpdateMutationHook(table) {
             moduleSpecifier: '../types',
             typeOnlyNamedImports: [typeName],
         }),
-    ]);
+    ];
+    // Add import for enum types from schema-types if any are used
+    if (usedEnums.size > 0) {
+        imports.push((0, ts_ast_1.createImport)({
+            moduleSpecifier: '../schema-types',
+            typeOnlyNamedImports: Array.from(usedEnums).sort(),
+        }));
+    }
+    // Add imports
+    sourceFile.addImportDeclarations(imports);
     // Re-export entity type
     sourceFile.addStatements(`\n// Re-export entity type for convenience\nexport type { ${typeName} };\n`);
     // Add section comment
@@ -188,9 +259,10 @@ function generateUpdateMutationHook(table) {
     sourceFile.addStatements('\n// ============================================================================');
     sourceFile.addStatements('// Types');
     sourceFile.addStatements('// ============================================================================\n');
-    // Generate Patch type - all fields optional
+    // Generate Patch type - all fields optional, exclude primary key
+    // Note: Not exported to avoid conflicts with schema-types
     const patchFields = scalarFields
-        .filter((f) => f.name.toLowerCase() !== 'id')
+        .filter((f) => !pkFieldNames.has(f.name))
         .map((f) => ({
         name: f.name,
         type: `${(0, utils_1.fieldTypeToTs)(f.type)} | null`,
@@ -198,13 +270,14 @@ function generateUpdateMutationHook(table) {
     }));
     sourceFile.addInterface((0, ts_ast_1.createInterface)(`${typeName}Patch`, patchFields, {
         docs: [`Patch type for updating a ${typeName} - all fields optional`],
+        isExported: false,
     }));
-    // Variables interface
+    // Variables interface - use dynamic PK field name and type
     sourceFile.addInterface((0, ts_ast_1.createInterface)(`${(0, utils_1.ucFirst)(mutationName)}MutationVariables`, [
         {
             name: 'input',
             type: `{
-    id: string;
+    ${pkField.name}: ${pkField.tsType};
     patch: ${typeName}Patch;
   }`,
         },
@@ -243,7 +316,7 @@ function generateUpdateMutationHook(table) {
       ),
     onSuccess: (_, variables) => {
       // Invalidate specific item and list queries
-      queryClient.invalidateQueries({ queryKey: ['${typeName.toLowerCase()}', 'detail', variables.input.id] });
+      queryClient.invalidateQueries({ queryKey: ['${typeName.toLowerCase()}', 'detail', variables.input.${pkField.name}] });
       queryClient.invalidateQueries({ queryKey: ['${typeName.toLowerCase()}', 'list'] });
     },
     ...options,
@@ -258,7 +331,7 @@ const { mutate, isPending } = ${hookName}();
 
 mutate({
   input: {
-    id: 'uuid-here',
+    ${pkField.name}: ${pkField.tsType === 'string' ? "'value-here'" : '123'},
     patch: {
       // ... fields to update
     },
@@ -278,8 +351,14 @@ mutate({
 // ============================================================================
 /**
  * Generate delete mutation hook file content using AST
+ * When reactQueryEnabled is false, returns null since mutations require React Query
  */
-function generateDeleteMutationHook(table) {
+function generateDeleteMutationHook(table, options = {}) {
+    const { reactQueryEnabled = true } = options;
+    // Mutations require React Query - skip generation when disabled
+    if (!reactQueryEnabled) {
+        return null;
+    }
     // Check if delete mutation exists
     if (table.query?.delete === null) {
         return null;
@@ -288,6 +367,9 @@ function generateDeleteMutationHook(table) {
     const { typeName } = (0, utils_1.getTableNames)(table);
     const hookName = (0, utils_1.getDeleteMutationHookName)(table);
     const mutationName = (0, utils_1.getDeleteMutationName)(table);
+    // Get primary key info dynamically from table constraints
+    const pkFields = (0, utils_1.getPrimaryKeyInfo)(table);
+    const pkField = pkFields[0]; // Use first PK field
     // Generate GraphQL document via AST
     const mutationAST = (0, gql_ast_1.buildDeleteMutationAST)({ table });
     const mutationDocument = (0, gql_ast_1.printGraphQL)(mutationAST);
@@ -316,12 +398,12 @@ function generateDeleteMutationHook(table) {
     sourceFile.addStatements('\n// ============================================================================');
     sourceFile.addStatements('// Types');
     sourceFile.addStatements('// ============================================================================\n');
-    // Variables interface
+    // Variables interface - use dynamic PK field name and type
     sourceFile.addInterface((0, ts_ast_1.createInterface)(`${(0, utils_1.ucFirst)(mutationName)}MutationVariables`, [
         {
             name: 'input',
             type: `{
-    id: string;
+    ${pkField.name}: ${pkField.tsType};
   }`,
         },
     ]));
@@ -331,7 +413,7 @@ function generateDeleteMutationHook(table) {
             name: mutationName,
             type: `{
     clientMutationId: string | null;
-    deletedId: string | null;
+    deleted${(0, utils_1.ucFirst)(pkField.name)}: ${pkField.tsType} | null;
   }`,
         },
     ]));
@@ -360,7 +442,7 @@ function generateDeleteMutationHook(table) {
       ),
     onSuccess: (_, variables) => {
       // Remove from cache and invalidate list
-      queryClient.removeQueries({ queryKey: ['${typeName.toLowerCase()}', 'detail', variables.input.id] });
+      queryClient.removeQueries({ queryKey: ['${typeName.toLowerCase()}', 'detail', variables.input.${pkField.name}] });
       queryClient.invalidateQueries({ queryKey: ['${typeName.toLowerCase()}', 'list'] });
     },
     ...options,
@@ -375,7 +457,7 @@ const { mutate, isPending } = ${hookName}();
 
 mutate({
   input: {
-    id: 'uuid-to-delete',
+    ${pkField.name}: ${pkField.tsType === 'string' ? "'value-to-delete'" : '123'},
   },
 });
 \`\`\``,
@@ -392,16 +474,20 @@ mutate({
 // ============================================================================
 /**
  * Generate all mutation hook files for all tables
+ * When reactQueryEnabled is false, returns empty array since mutations require React Query
  */
-function generateAllMutationHooks(tables) {
+function generateAllMutationHooks(tables, options = {}) {
     const files = [];
     for (const table of tables) {
-        files.push(generateCreateMutationHook(table));
-        const updateHook = generateUpdateMutationHook(table);
+        const createHook = generateCreateMutationHook(table, options);
+        if (createHook) {
+            files.push(createHook);
+        }
+        const updateHook = generateUpdateMutationHook(table, options);
         if (updateHook) {
             files.push(updateHook);
         }
-        const deleteHook = generateDeleteMutationHook(table);
+        const deleteHook = generateDeleteMutationHook(table, options);
         if (deleteHook) {
             files.push(deleteHook);
         }

package/cli/codegen/orm/barrel.js

@@ -16,9 +16,11 @@ function generateModelsBarrel(tables) {
     for (const table of tables) {
         const { typeName } = (0, utils_1.getTableNames)(table);
         const modelName = `${typeName}Model`;
-        const fileName = (0, utils_1.lcFirst)(typeName);
+        // Use same naming logic as model-generator to avoid "index.ts" clash with barrel file
+        const baseFileName = (0, utils_1.lcFirst)(typeName);
+        const moduleFileName = baseFileName === 'index' ? `${baseFileName}Model` : baseFileName;
         sourceFile.addExportDeclaration({
-            moduleSpecifier: `./${fileName}`,
+            moduleSpecifier: `./${moduleFileName}`,
             namedExports: [modelName],
         });
     }

package/cli/codegen/orm/index.js

@@ -44,6 +44,23 @@ function generateOrm(options) {
         ];
         const usedInputTypes = (0, input_types_generator_1.collectInputTypeNames)(allOps);
         const usedPayloadTypes = (0, input_types_generator_1.collectPayloadTypeNames)(allOps);
+        // Also include payload types for table CRUD mutations (they reference Edge types)
+        if (typeRegistry) {
+            for (const table of tables) {
+                const typeName = table.name;
+                // Add standard CRUD payload types
+                const crudPayloadTypes = [
+                    `Create${typeName}Payload`,
+                    `Update${typeName}Payload`,
+                    `Delete${typeName}Payload`,
+                ];
+                for (const payloadType of crudPayloadTypes) {
+                    if (typeRegistry.has(payloadType)) {
+                        usedPayloadTypes.add(payloadType);
+                    }
+                }
+            }
+        }
         const inputTypesFile = (0, input_types_generator_1.generateInputTypesFile)(typeRegistry ?? new Map(), usedInputTypes, tables, usedPayloadTypes);
         files.push({ path: inputTypesFile.fileName, content: inputTypesFile.content });
     }

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

@@ -122,6 +122,47 @@ function addScalarFilterTypes(sourceFile) {
     }
 }
 // ============================================================================
+// Enum Types Collector
+// ============================================================================
+/**
+ * Check if a type is likely an enum (not a scalar and not ending with Input/Filter/etc)
+ */
+function isLikelyEnumType(typeName, typeRegistry) {
+    const typeInfo = typeRegistry.get(typeName);
+    return typeInfo?.kind === 'ENUM';
+}
+/**
+ * Collect enum types used by table fields
+ */
+function collectEnumTypesFromTables(tables, typeRegistry) {
+    const enumTypes = new Set();
+    for (const table of tables) {
+        for (const field of table.fields) {
+            const fieldType = typeof field.type === 'string' ? field.type : field.type.gqlType;
+            // Check if this type is an enum in the registry
+            if (isLikelyEnumType(fieldType, typeRegistry)) {
+                enumTypes.add(fieldType);
+            }
+        }
+    }
+    return enumTypes;
+}
+/**
+ * Add enum types to source file
+ */
+function addEnumTypes(sourceFile, typeRegistry, enumTypeNames) {
+    if (enumTypeNames.size === 0)
+        return;
+    (0, ts_ast_1.addSectionComment)(sourceFile, 'Enum Types');
+    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));
+    }
+}
+// ============================================================================
 // Entity Types Generator (AST-based)
 // ============================================================================
 /**
@@ -387,10 +428,12 @@ function buildOrderByUnion(table) {
 }
 /**
  * Add OrderBy types
+ * Uses inflection from table metadata for correct pluralization
  */
 function addOrderByTypes(sourceFile, tables) {
     (0, ts_ast_1.addSectionComment)(sourceFile, 'OrderBy Types');
     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)));
     }
@@ -509,32 +552,39 @@ function collectInputTypeNames(operations) {
     }
     return inputTypes;
 }
+/**
+ * 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
+ */
+function buildTableCrudTypeNames(tables) {
+    const crudTypes = new Set();
+    for (const table of tables) {
+        const { typeName } = (0, utils_1.getTableNames)(table);
+        crudTypes.add(`Create${typeName}Input`);
+        crudTypes.add(`Update${typeName}Input`);
+        crudTypes.add(`Delete${typeName}Input`);
+        crudTypes.add(`${typeName}Filter`);
+        crudTypes.add(`${typeName}Patch`);
+    }
+    return crudTypes;
+}
 /**
  * Add custom input types from TypeRegistry
  */
-function addCustomInputTypes(sourceFile, typeRegistry, usedInputTypes) {
+function addCustomInputTypes(sourceFile, typeRegistry, usedInputTypes, tableCrudTypes) {
     (0, ts_ast_1.addSectionComment)(sourceFile, 'Custom Input Types (from schema)');
     const generatedTypes = new Set();
     const typesToGenerate = new Set(Array.from(usedInputTypes));
-    // Filter out types we've already generated
-    const typesToRemove = [];
-    typesToGenerate.forEach((typeName) => {
-        if (typeName.endsWith('Filter') ||
-            typeName.startsWith('Create') ||
-            typeName.startsWith('Update') ||
-            typeName.startsWith('Delete')) {
-            const isTableCrud = /^(Create|Update|Delete)[A-Z][a-zA-Z]+Input$/.test(typeName) ||
-                /^[A-Z][a-zA-Z]+Filter$/.test(typeName);
-            if (isTableCrud) {
-                typesToRemove.push(typeName);
+    // Filter out types we've already generated (exact matches for table CRUD types only)
+    if (tableCrudTypes) {
+        for (const typeName of Array.from(typesToGenerate)) {
+            if (tableCrudTypes.has(typeName)) {
+                typesToGenerate.delete(typeName);
             }
         }
-    });
-    typesToRemove.forEach((t) => typesToGenerate.delete(t));
-    let iterations = 0;
-    const maxIterations = 200;
-    while (typesToGenerate.size > 0 && iterations < maxIterations) {
-        iterations++;
+    }
+    // Process all types - no artificial limit
+    while (typesToGenerate.size > 0) {
         const typeNameResult = typesToGenerate.values().next();
         if (typeNameResult.done)
             break;
@@ -600,10 +650,8 @@ function addPayloadTypes(sourceFile, typeRegistry, usedPayloadTypes, alreadyGene
         'String', 'Int', 'Float', 'Boolean', 'ID', 'UUID', 'Datetime', 'Date',
         'Time', 'JSON', 'BigInt', 'BigFloat', 'Cursor', 'Query', 'Mutation',
     ]);
-    let iterations = 0;
-    const maxIterations = 200;
-    while (typesToGenerate.size > 0 && iterations < maxIterations) {
-        iterations++;
+    // Process all types - no artificial limit
+    while (typesToGenerate.size > 0) {
         const typeNameResult = typesToGenerate.values().next();
         if (typeNameResult.done)
             break;
@@ -670,7 +718,12 @@ function generateInputTypesFile(typeRegistry, usedInputTypes, tables, usedPayloa
     sourceFile.insertText(0, (0, ts_ast_1.createFileHeader)('GraphQL types for ORM client') + '\n');
     // 1. Scalar filter types
     addScalarFilterTypes(sourceFile);
-    // 2. Entity and relation types (if tables provided)
+    // 2. Enum types used by table fields
+    if (tables && tables.length > 0) {
+        const enumTypes = collectEnumTypesFromTables(tables, typeRegistry);
+        addEnumTypes(sourceFile, 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);
@@ -678,16 +731,17 @@ function generateInputTypesFile(typeRegistry, usedInputTypes, tables, usedPayloa
         addEntityRelationTypes(sourceFile, tables, tableByName);
         addEntityWithRelations(sourceFile, tables);
         addEntitySelectTypes(sourceFile, tables, tableByName);
-        // 3. Table filter types
+        // 4. Table filter types
         addTableFilterTypes(sourceFile, tables);
-        // 4. OrderBy types
+        // 5. OrderBy types
         addOrderByTypes(sourceFile, tables);
-        // 5. CRUD input types
+        // 6. CRUD input types
         addAllCrudInputTypes(sourceFile, tables);
     }
-    // 6. Custom input types from TypeRegistry
-    addCustomInputTypes(sourceFile, typeRegistry, usedInputTypes);
-    // 7. Payload/return types for custom operations
+    // 7. Custom input types from TypeRegistry
+    const tableCrudTypes = tables ? buildTableCrudTypeNames(tables) : undefined;
+    addCustomInputTypes(sourceFile, typeRegistry, usedInputTypes, tableCrudTypes);
+    // 8. Payload/return types for custom operations
     if (usedPayloadTypes && usedPayloadTypes.size > 0) {
         const alreadyGeneratedTypes = new Set();
         if (tables) {