@constructive-io/graphql-codegen 2.21.0 → 2.22.0

package/esm/cli/codegen/index.js

@@ -1,10 +1,12 @@
 import { generateClientFile } from './client';
 import { generateTypesFile } from './types';
+import { generateSchemaTypesFile } from './schema-types-generator';
 import { generateAllQueryHooks } from './queries';
 import { generateAllMutationHooks } from './mutations';
 import { generateAllCustomQueryHooks } from './custom-queries';
 import { generateAllCustomMutationHooks } from './custom-mutations';
 import { generateQueriesBarrel, generateMutationsBarrel, generateMainBarrel, generateCustomQueriesBarrel, generateCustomMutationsBarrel, } from './barrel';
+import { getTableNames } from './utils';
 // ============================================================================
 // Main orchestrator
 // ============================================================================
@@ -29,12 +31,33 @@ export function generate(options) {
         path: 'client.ts',
         content: generateClientFile(),
     });
-    // 2. Generate types.ts
+    // Collect table type names for import path resolution
+    const tableTypeNames = new Set(tables.map((t) => 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 = 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: generateTypesFile(tables),
+        content: generateTypesFile(tables, { enumsFromSchemaTypes: generatedEnumNames }),
     });
-    // 3. Generate table-based query hooks (queries/*.ts)
+    // 4. Generate table-based query hooks (queries/*.ts)
     const queryHooks = generateAllQueryHooks(tables, { reactQueryEnabled });
     for (const hook of queryHooks) {
         files.push({
@@ -42,7 +65,7 @@ export function generate(options) {
             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 = generateAllCustomQueryHooks({
@@ -51,6 +74,7 @@ export function generate(options) {
             maxDepth,
             skipQueryField,
             reactQueryEnabled,
+            tableTypeNames,
         });
         for (const hook of customQueryHooks) {
             files.push({
@@ -67,7 +91,10 @@ export function generate(options) {
             : generateQueriesBarrel(tables),
     });
     // 6. Generate table-based mutation hooks (mutations/*.ts)
-    const mutationHooks = generateAllMutationHooks(tables, { reactQueryEnabled });
+    const mutationHooks = generateAllMutationHooks(tables, {
+        reactQueryEnabled,
+        enumsFromSchemaTypes: generatedEnumNames,
+    });
     for (const hook of mutationHooks) {
         files.push({
             path: `mutations/${hook.fileName}`,
@@ -83,6 +110,7 @@ export function generate(options) {
             maxDepth,
             skipQueryField,
             reactQueryEnabled,
+            tableTypeNames,
         });
         for (const hook of customMutationHooks) {
             files.push({
@@ -98,10 +126,10 @@ export function generate(options) {
             ? generateCustomMutationsBarrel(tables, customMutationHooks.map((h) => h.operationName))
             : 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: generateMainBarrel(tables),
+        content: generateMainBarrel(tables, hasSchemaTypes),
     });
     return {
         files,

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

@@ -15,6 +15,8 @@ export interface GeneratedMutationFile {
 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

package/esm/cli/codegen/mutations.js

@@ -1,6 +1,24 @@
 import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, createInterface, createConst, } from './ts-ast';
 import { buildCreateMutationAST, buildUpdateMutationAST, buildDeleteMutationAST, printGraphQL, } from './gql-ast';
-import { getTableNames, getCreateMutationHookName, getUpdateMutationHookName, getDeleteMutationHookName, getCreateMutationFileName, getUpdateMutationFileName, getDeleteMutationFileName, getCreateMutationName, getUpdateMutationName, getDeleteMutationName, getScalarFields, fieldTypeToTs, ucFirst, lcFirst, } from './utils';
+import { getTableNames, getCreateMutationHookName, getUpdateMutationHookName, getDeleteMutationHookName, getCreateMutationFileName, getUpdateMutationFileName, getDeleteMutationFileName, getCreateMutationName, getUpdateMutationName, getDeleteMutationName, getScalarFields, getPrimaryKeyInfo, fieldTypeToTs, ucFirst, lcFirst, } from './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
 // ============================================================================
@@ -9,24 +27,35 @@ import { getTableNames, getCreateMutationHookName, getUpdateMutationHookName, ge
  * When reactQueryEnabled is false, returns null since mutations require React Query
  */
 export function generateCreateMutationHook(table, options = {}) {
-    const { reactQueryEnabled = true } = 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 = createProject();
     const { typeName, singularName } = getTableNames(table);
     const hookName = getCreateMutationHookName(table);
     const mutationName = getCreateMutationName(table);
     const scalarFields = getScalarFields(table);
+    // Get primary key field names dynamically from table constraints
+    const pkFieldNames = new Set(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 = buildCreateMutationAST({ table });
     const mutationDocument = printGraphQL(mutationAST);
     const sourceFile = createSourceFile(project, getCreateMutationFileName(table));
     // Add file header
     sourceFile.insertText(0, createFileHeader(`Create mutation hook for ${typeName}`) + '\n\n');
-    // Add imports
-    sourceFile.addImportDeclarations([
+    // Build import declarations
+    const imports = [
         createImport({
             moduleSpecifier: '@tanstack/react-query',
             namedImports: ['useMutation', 'useQueryClient'],
@@ -40,7 +69,16 @@ export function generateCreateMutationHook(table, options = {}) {
             moduleSpecifier: '../types',
             typeOnlyNamedImports: [typeName],
         }),
-    ]);
+    ];
+    // Add import for enum types from schema-types if any are used
+    if (usedEnums.size > 0) {
+        imports.push(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 +92,9 @@ export function generateCreateMutationHook(table, options = {}) {
     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: `${fieldTypeToTs(f.type)} | null`,
@@ -66,6 +102,7 @@ export function generateCreateMutationHook(table, options = {}) {
     }));
     sourceFile.addInterface(createInterface(`${typeName}CreateInput`, inputFields, {
         docs: [`Input type for creating a ${typeName}`],
+        isExported: false,
     }));
     // Variables interface
     sourceFile.addInterface(createInterface(`${ucFirst(mutationName)}MutationVariables`, [
@@ -146,7 +183,7 @@ mutate({
  * When reactQueryEnabled is false, returns null since mutations require React Query
  */
 export function generateUpdateMutationHook(table, options = {}) {
-    const { reactQueryEnabled = true } = options;
+    const { reactQueryEnabled = true, enumsFromSchemaTypes = [] } = options;
     // Mutations require React Query - skip generation when disabled
     if (!reactQueryEnabled) {
         return null;
@@ -155,19 +192,32 @@ export function generateUpdateMutationHook(table, options = {}) {
     if (table.query?.update === null) {
         return null;
     }
+    const enumSet = new Set(enumsFromSchemaTypes);
     const project = createProject();
     const { typeName, singularName } = getTableNames(table);
     const hookName = getUpdateMutationHookName(table);
     const mutationName = getUpdateMutationName(table);
     const scalarFields = getScalarFields(table);
+    // Get primary key info dynamically from table constraints
+    const pkFields = 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 = buildUpdateMutationAST({ table });
     const mutationDocument = printGraphQL(mutationAST);
     const sourceFile = createSourceFile(project, getUpdateMutationFileName(table));
     // Add file header
     sourceFile.insertText(0, createFileHeader(`Update mutation hook for ${typeName}`) + '\n\n');
-    // Add imports
-    sourceFile.addImportDeclarations([
+    // Build import declarations
+    const imports = [
         createImport({
             moduleSpecifier: '@tanstack/react-query',
             namedImports: ['useMutation', 'useQueryClient'],
@@ -181,7 +231,16 @@ export function generateUpdateMutationHook(table, options = {}) {
             moduleSpecifier: '../types',
             typeOnlyNamedImports: [typeName],
         }),
-    ]);
+    ];
+    // Add import for enum types from schema-types if any are used
+    if (usedEnums.size > 0) {
+        imports.push(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
@@ -194,9 +253,10 @@ export function generateUpdateMutationHook(table, options = {}) {
     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: `${fieldTypeToTs(f.type)} | null`,
@@ -204,13 +264,14 @@ export function generateUpdateMutationHook(table, options = {}) {
     }));
     sourceFile.addInterface(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(createInterface(`${ucFirst(mutationName)}MutationVariables`, [
         {
             name: 'input',
             type: `{
-    id: string;
+    ${pkField.name}: ${pkField.tsType};
     patch: ${typeName}Patch;
   }`,
         },
@@ -249,7 +310,7 @@ export function generateUpdateMutationHook(table, options = {}) {
       ),
     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,
@@ -264,7 +325,7 @@ const { mutate, isPending } = ${hookName}();
 
 mutate({
   input: {
-    id: 'uuid-here',
+    ${pkField.name}: ${pkField.tsType === 'string' ? "'value-here'" : '123'},
     patch: {
       // ... fields to update
     },
@@ -300,6 +361,9 @@ export function generateDeleteMutationHook(table, options = {}) {
     const { typeName } = getTableNames(table);
     const hookName = getDeleteMutationHookName(table);
     const mutationName = getDeleteMutationName(table);
+    // Get primary key info dynamically from table constraints
+    const pkFields = getPrimaryKeyInfo(table);
+    const pkField = pkFields[0]; // Use first PK field
     // Generate GraphQL document via AST
     const mutationAST = buildDeleteMutationAST({ table });
     const mutationDocument = printGraphQL(mutationAST);
@@ -328,12 +392,12 @@ export function generateDeleteMutationHook(table, options = {}) {
     sourceFile.addStatements('\n// ============================================================================');
     sourceFile.addStatements('// Types');
     sourceFile.addStatements('// ============================================================================\n');
-    // Variables interface
+    // Variables interface - use dynamic PK field name and type
     sourceFile.addInterface(createInterface(`${ucFirst(mutationName)}MutationVariables`, [
         {
             name: 'input',
             type: `{
-    id: string;
+    ${pkField.name}: ${pkField.tsType};
   }`,
         },
     ]));
@@ -343,7 +407,7 @@ export function generateDeleteMutationHook(table, options = {}) {
             name: mutationName,
             type: `{
     clientMutationId: string | null;
-    deletedId: string | null;
+    deleted${ucFirst(pkField.name)}: ${pkField.tsType} | null;
   }`,
         },
     ]));
@@ -372,7 +436,7 @@ export function generateDeleteMutationHook(table, options = {}) {
       ),
     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,
@@ -387,7 +451,7 @@ const { mutate, isPending } = ${hookName}();
 
 mutate({
   input: {
-    id: 'uuid-to-delete',
+    ${pkField.name}: ${pkField.tsType === 'string' ? "'value-to-delete'" : '123'},
   },
 });
 \`\`\``,

package/esm/cli/codegen/orm/barrel.js

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

package/esm/cli/codegen/orm/index.js

@@ -40,6 +40,23 @@ export function generateOrm(options) {
         ];
         const usedInputTypes = collectInputTypeNames(allOps);
         const usedPayloadTypes = 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 = generateInputTypesFile(typeRegistry ?? new Map(), usedInputTypes, tables, usedPayloadTypes);
         files.push({ path: inputTypesFile.fileName, content: inputTypesFile.content });
     }

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

@@ -117,6 +117,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;
+    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(createTypeAlias(typeName, values));
+    }
+}
+// ============================================================================
 // Entity Types Generator (AST-based)
 // ============================================================================
 /**
@@ -382,10 +423,12 @@ function buildOrderByUnion(table) {
 }
 /**
  * Add OrderBy types
+ * Uses inflection from table metadata for correct pluralization
  */
 function addOrderByTypes(sourceFile, tables) {
     addSectionComment(sourceFile, 'OrderBy Types');
     for (const table of tables) {
+        // Use getOrderByTypeName which respects table.inflection.orderByType
         const enumName = getOrderByTypeName(table);
         sourceFile.addTypeAlias(createTypeAlias(enumName, buildOrderByUnion(table)));
     }
@@ -504,32 +547,39 @@ export 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 } = 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) {
     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;
@@ -595,10 +645,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;
@@ -665,7 +713,12 @@ export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, use
     sourceFile.insertText(0, 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);
@@ -673,16 +726,17 @@ export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, use
         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) {

package/esm/cli/codegen/orm/model-generator.js

@@ -1,5 +1,5 @@
 import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, } from '../ts-ast';
-import { getTableNames, lcFirst } from '../utils';
+import { getTableNames, getOrderByTypeName, getFilterTypeName, lcFirst } from '../utils';
 /**
  * Generate a model class file for a table
  */
@@ -7,13 +7,15 @@ export function generateModelFile(table, _useSharedTypes) {
     const project = createProject();
     const { typeName, singularName, pluralName } = getTableNames(table);
     const modelName = `${typeName}Model`;
-    const fileName = `${lcFirst(typeName)}.ts`;
+    // Avoid "index.ts" which clashes with barrel file
+    const baseFileName = lcFirst(typeName);
+    const fileName = baseFileName === 'index' ? `${baseFileName}Model.ts` : `${baseFileName}.ts`;
     const entityLower = singularName;
-    // Type names for this entity
+    // Type names for this entity - use inflection from table metadata
     const selectTypeName = `${typeName}Select`;
     const relationTypeName = `${typeName}WithRelations`;
-    const whereTypeName = `${typeName}Filter`;
-    const orderByTypeName = `${typeName}sOrderBy`; // PostGraphile uses plural
+    const whereTypeName = getFilterTypeName(table);
+    const orderByTypeName = getOrderByTypeName(table);
     const createInputTypeName = `Create${typeName}Input`;
     const updateInputTypeName = `Update${typeName}Input`;
     const deleteInputTypeName = `Delete${typeName}Input`;