@constructive-io/graphql-codegen 2.21.0 → 2.22.0

package/esm/cli/codegen/type-resolver.d.ts

@@ -6,6 +6,34 @@
  */
 import type { CleanTypeRef, CleanArgument, CleanObjectField } from '../../types/schema';
 import type { InterfaceProperty } from './ts-ast';
+/**
+ * Interface for tracking referenced types during code generation
+ */
+export interface TypeTracker {
+    /** Set of type names that have been referenced */
+    referencedTypes: Set<string>;
+    /** Track a type reference */
+    track(typeName: string): void;
+    /** Get importable types from schema-types.ts (Input/Payload/Enum types) */
+    getImportableTypes(): string[];
+    /** Get importable types from types.ts (table entity types) */
+    getTableTypes(): string[];
+    /** Reset the tracker */
+    reset(): void;
+}
+/**
+ * Options for creating a TypeTracker
+ */
+export interface TypeTrackerOptions {
+    /** Table entity type names that should be imported from types.ts */
+    tableTypeNames?: Set<string>;
+}
+/**
+ * Create a new TypeTracker instance
+ *
+ * @param options - Optional configuration for the tracker
+ */
+export declare function createTypeTracker(options?: TypeTrackerOptions): TypeTracker;
 /**
  * Convert a GraphQL scalar type to TypeScript type
  */
@@ -13,13 +41,19 @@ export declare function scalarToTsType(scalarName: string): string;
 /**
  * Convert a CleanTypeRef to a TypeScript type string
  * Handles nested LIST and NON_NULL wrappers
+ *
+ * @param typeRef - The GraphQL type reference
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export declare function typeRefToTsType(typeRef: CleanTypeRef): string;
+export declare function typeRefToTsType(typeRef: CleanTypeRef, tracker?: TypeTracker): string;
 /**
  * Convert a CleanTypeRef to a nullable TypeScript type string
  * (for optional fields that can be null)
+ *
+ * @param typeRef - The GraphQL type reference
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export declare function typeRefToNullableTsType(typeRef: CleanTypeRef): string;
+export declare function typeRefToNullableTsType(typeRef: CleanTypeRef, tracker?: TypeTracker): string;
 /**
  * Check if a type reference is required (wrapped in NON_NULL)
  */
@@ -38,20 +72,32 @@ export declare function getTypeBaseName(typeRef: CleanTypeRef): string | 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): InterfaceProperty;
+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): InterfaceProperty;
+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[]): InterfaceProperty[];
+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[]): InterfaceProperty[];
+export declare function fieldsToInterfaceProperties(fields: CleanObjectField[], tracker?: TypeTracker): InterfaceProperty[];
 /**
  * Check if a field should be skipped in selections
  */

package/esm/cli/codegen/type-resolver.js

@@ -1,4 +1,57 @@
-import { scalarToTsType as resolveScalarToTs } from './scalars';
+import { scalarToTsType as resolveScalarToTs, SCALAR_NAMES } from './scalars';
+// ============================================================================
+// Type Tracker for Collecting Referenced Types
+// ============================================================================
+/**
+ * Types that should not be tracked (scalars, built-ins, internal types)
+ */
+const SKIP_TYPE_TRACKING = new Set([
+    ...SCALAR_NAMES,
+    // GraphQL built-ins
+    'Query',
+    'Mutation',
+    'Subscription',
+    '__Schema',
+    '__Type',
+    '__Field',
+    '__InputValue',
+    '__EnumValue',
+    '__Directive',
+    // Connection types (handled separately)
+    'PageInfo',
+]);
+/**
+ * Create a new TypeTracker instance
+ *
+ * @param options - Optional configuration for the tracker
+ */
+export function createTypeTracker(options) {
+    const referencedTypes = new Set();
+    const tableTypeNames = options?.tableTypeNames ?? new Set();
+    return {
+        referencedTypes,
+        track(typeName) {
+            if (typeName && !SKIP_TYPE_TRACKING.has(typeName)) {
+                referencedTypes.add(typeName);
+            }
+        },
+        getImportableTypes() {
+            // Return schema types (not table entity types)
+            return Array.from(referencedTypes)
+                .filter((name) => !tableTypeNames.has(name))
+                .sort();
+        },
+        getTableTypes() {
+            // Return table entity types only
+            return Array.from(referencedTypes)
+                .filter((name) => tableTypeNames.has(name))
+                .sort();
+        },
+        reset() {
+            referencedTypes.clear();
+        },
+    };
+}
 // ============================================================================
 // GraphQL to TypeScript Type Mapping
 // ============================================================================
@@ -14,32 +67,41 @@ export function scalarToTsType(scalarName) {
 /**
  * Convert a CleanTypeRef to a TypeScript type string
  * Handles nested LIST and NON_NULL wrappers
+ *
+ * @param typeRef - The GraphQL type reference
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export function typeRefToTsType(typeRef) {
+export function typeRefToTsType(typeRef, tracker) {
     switch (typeRef.kind) {
         case 'NON_NULL':
             // Non-null wrapper - unwrap and return the inner type
             if (typeRef.ofType) {
-                return typeRefToTsType(typeRef.ofType);
+                return typeRefToTsType(typeRef.ofType, tracker);
             }
             return 'unknown';
         case 'LIST':
             // List wrapper - wrap inner type in array
             if (typeRef.ofType) {
-                const innerType = typeRefToTsType(typeRef.ofType);
+                const innerType = typeRefToTsType(typeRef.ofType, tracker);
                 return `${innerType}[]`;
             }
             return 'unknown[]';
         case 'SCALAR':
             // Scalar type - map to TS type
             return scalarToTsType(typeRef.name ?? 'unknown');
-        case 'ENUM':
-            // Enum type - use the GraphQL enum name
-            return typeRef.name ?? 'string';
+        case 'ENUM': {
+            // Enum type - use the GraphQL enum name and track it
+            const typeName = typeRef.name ?? 'string';
+            tracker?.track(typeName);
+            return typeName;
+        }
         case 'OBJECT':
-        case 'INPUT_OBJECT':
-            // Object types - use the GraphQL type name
-            return typeRef.name ?? 'unknown';
+        case 'INPUT_OBJECT': {
+            // Object types - use the GraphQL type name and track it
+            const typeName = typeRef.name ?? 'unknown';
+            tracker?.track(typeName);
+            return typeName;
+        }
         default:
             return 'unknown';
     }
@@ -47,9 +109,12 @@ export function typeRefToTsType(typeRef) {
 /**
  * Convert a CleanTypeRef to a nullable TypeScript type string
  * (for optional fields that can be null)
+ *
+ * @param typeRef - The GraphQL type reference
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export function typeRefToNullableTsType(typeRef) {
-    const baseType = typeRefToTsType(typeRef);
+export function typeRefToNullableTsType(typeRef, tracker) {
+    const baseType = typeRefToTsType(typeRef, tracker);
     // If the outer type is NON_NULL, it's required
     if (typeRef.kind === 'NON_NULL') {
         return baseType;
@@ -100,37 +165,49 @@ export function getBaseTypeKind(typeRef) {
 // ============================================================================
 /**
  * Convert CleanArgument to InterfaceProperty for ts-morph
+ *
+ * @param arg - The GraphQL argument
+ * @param tracker - Optional TypeTracker to collect referenced types
  */
-export function argumentToInterfaceProperty(arg) {
+export function argumentToInterfaceProperty(arg, tracker) {
     return {
         name: arg.name,
-        type: typeRefToTsType(arg.type),
+        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
  */
-export function fieldToInterfaceProperty(field) {
+export function fieldToInterfaceProperty(field, tracker) {
     return {
         name: field.name,
-        type: typeRefToNullableTsType(field.type),
+        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
  */
-export function argumentsToInterfaceProperties(args) {
-    return args.map(argumentToInterfaceProperty);
+export 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
  */
-export function fieldsToInterfaceProperties(fields) {
-    return fields.map(fieldToInterfaceProperty);
+export function fieldsToInterfaceProperties(fields, tracker) {
+    return fields.map((field) => fieldToInterfaceProperty(field, tracker));
 }
 // ============================================================================
 // Type Filtering

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

@@ -3,10 +3,13 @@
  */
 import type { CleanTable } from '../../types/schema';
 /**
- * Generate types.ts content with all entity interfaces and base filter types
+ * Options for generating types.ts
  */
-export declare function generateTypesFile(tables: CleanTable[]): string;
+export interface GenerateTypesOptions {
+    /** Enum type names that are available from schema-types.ts */
+    enumsFromSchemaTypes?: string[];
+}
 /**
- * Generate a minimal entity type (just id and display fields)
+ * Generate types.ts content with all entity interfaces and base filter types
  */
-export declare function generateMinimalEntityType(table: CleanTable): string;
+export declare function generateTypesFile(tables: CleanTable[], options?: GenerateTypesOptions): string;

package/esm/cli/codegen/types.js

@@ -1,15 +1,100 @@
-import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createInterface, } from './ts-ast';
+import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, createInterface, } from './ts-ast';
 import { getScalarFields, fieldTypeToTs } from './utils';
-import { generateBaseFilterTypes } from './filters';
+/** All filter type configurations - scalar and list filters */
+const FILTER_CONFIGS = [
+    // Scalar filters
+    { name: 'StringFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray', 'comparison', 'string'] },
+    { name: 'IntFilter', tsType: 'number', operators: ['equality', 'distinct', 'inArray', 'comparison'] },
+    { name: 'FloatFilter', tsType: 'number', operators: ['equality', 'distinct', 'inArray', 'comparison'] },
+    { name: 'BooleanFilter', tsType: 'boolean', operators: ['equality'] },
+    { name: 'UUIDFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray'] },
+    { name: 'DatetimeFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray', 'comparison'] },
+    { name: 'DateFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray', 'comparison'] },
+    { name: 'JSONFilter', tsType: 'Record<string, unknown>', operators: ['equality', 'distinct', 'json'] },
+    { name: 'BigIntFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray', 'comparison'] },
+    { name: 'BigFloatFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray', 'comparison'] },
+    { name: 'BitStringFilter', tsType: 'string', operators: ['equality'] },
+    { name: 'InternetAddressFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray', 'comparison', 'inet'] },
+    { name: 'FullTextFilter', tsType: 'string', operators: ['fulltext'] },
+    // List filters
+    { name: 'StringListFilter', tsType: 'string[]', operators: ['equality', 'distinct', 'comparison', 'listArray'] },
+    { name: 'IntListFilter', tsType: 'number[]', operators: ['equality', 'distinct', 'comparison', 'listArray'] },
+    { name: 'UUIDListFilter', tsType: 'string[]', operators: ['equality', 'distinct', 'comparison', 'listArray'] },
+];
+/** Build filter properties based on operator sets */
+function buildFilterProperties(tsType, operators) {
+    const props = [];
+    // Equality operators (isNull, equalTo, notEqualTo)
+    if (operators.includes('equality')) {
+        props.push({ name: 'isNull', type: 'boolean', optional: true }, { name: 'equalTo', type: tsType, optional: true }, { name: 'notEqualTo', type: tsType, optional: true });
+    }
+    // Distinct operators
+    if (operators.includes('distinct')) {
+        props.push({ name: 'distinctFrom', type: tsType, optional: true }, { name: 'notDistinctFrom', type: tsType, optional: true });
+    }
+    // In array operators
+    if (operators.includes('inArray')) {
+        props.push({ name: 'in', type: `${tsType}[]`, optional: true }, { name: 'notIn', type: `${tsType}[]`, optional: true });
+    }
+    // Comparison operators (lt, lte, gt, gte)
+    if (operators.includes('comparison')) {
+        props.push({ name: 'lessThan', type: tsType, optional: true }, { name: 'lessThanOrEqualTo', type: tsType, optional: true }, { name: 'greaterThan', type: tsType, optional: true }, { name: 'greaterThanOrEqualTo', type: tsType, optional: true });
+    }
+    // String-specific operators
+    if (operators.includes('string')) {
+        props.push({ name: 'includes', type: 'string', optional: true }, { name: 'notIncludes', type: 'string', optional: true }, { name: 'includesInsensitive', type: 'string', optional: true }, { name: 'notIncludesInsensitive', type: 'string', optional: true }, { name: 'startsWith', type: 'string', optional: true }, { name: 'notStartsWith', type: 'string', optional: true }, { name: 'startsWithInsensitive', type: 'string', optional: true }, { name: 'notStartsWithInsensitive', type: 'string', optional: true }, { name: 'endsWith', type: 'string', optional: true }, { name: 'notEndsWith', type: 'string', optional: true }, { name: 'endsWithInsensitive', type: 'string', optional: true }, { name: 'notEndsWithInsensitive', type: 'string', optional: true }, { name: 'like', type: 'string', optional: true }, { name: 'notLike', type: 'string', optional: true }, { name: 'likeInsensitive', type: 'string', optional: true }, { name: 'notLikeInsensitive', type: 'string', optional: true });
+    }
+    // JSON-specific operators
+    if (operators.includes('json')) {
+        props.push({ name: 'contains', type: 'unknown', optional: true }, { name: 'containedBy', type: 'unknown', optional: true }, { name: 'containsKey', type: 'string', optional: true }, { name: 'containsAllKeys', type: 'string[]', optional: true }, { name: 'containsAnyKeys', type: 'string[]', optional: true });
+    }
+    // Internet address operators
+    if (operators.includes('inet')) {
+        props.push({ name: 'contains', type: 'string', optional: true }, { name: 'containedBy', type: 'string', optional: true }, { name: 'containsOrContainedBy', type: 'string', optional: true });
+    }
+    // Full-text search operator
+    if (operators.includes('fulltext')) {
+        props.push({ name: 'matches', type: 'string', optional: true });
+    }
+    // List/Array operators (for StringListFilter, IntListFilter, etc.)
+    if (operators.includes('listArray')) {
+        // Extract base type from array type (e.g., 'string[]' -> 'string')
+        const baseType = tsType.replace('[]', '');
+        props.push({ name: 'contains', type: tsType, optional: true }, { name: 'containedBy', type: tsType, optional: true }, { name: 'overlaps', type: tsType, optional: true }, { name: 'anyEqualTo', type: baseType, optional: true }, { name: 'anyNotEqualTo', type: baseType, optional: true }, { name: 'anyLessThan', type: baseType, optional: true }, { name: 'anyLessThanOrEqualTo', type: baseType, optional: true }, { name: 'anyGreaterThan', type: baseType, optional: true }, { name: 'anyGreaterThanOrEqualTo', type: baseType, optional: true });
+    }
+    return props;
+}
 /**
  * Generate types.ts content with all entity interfaces and base filter types
  */
-export function generateTypesFile(tables) {
+export function generateTypesFile(tables, options = {}) {
+    const { enumsFromSchemaTypes = [] } = options;
+    const enumSet = new Set(enumsFromSchemaTypes);
     const project = createProject();
     const sourceFile = createSourceFile(project, 'types.ts');
     // Add file header
     sourceFile.insertText(0, createFileHeader('Entity types and filter types') + '\n\n');
-    // Add section comment
+    // Collect which enums are actually used by entity fields
+    const usedEnums = new Set();
+    for (const table of tables) {
+        const scalarFields = getScalarFields(table);
+        for (const field of scalarFields) {
+            // Check if the field's gqlType matches any known enum
+            const cleanType = field.type.gqlType.replace(/!/g, '');
+            if (enumSet.has(cleanType)) {
+                usedEnums.add(cleanType);
+            }
+        }
+    }
+    // Add import for enum types from schema-types if any are used
+    if (usedEnums.size > 0) {
+        sourceFile.addImportDeclaration(createImport({
+            moduleSpecifier: './schema-types',
+            typeOnlyNamedImports: Array.from(usedEnums).sort(),
+        }));
+        sourceFile.addStatements('');
+    }
+    // Add section comment for entity types
     sourceFile.addStatements('// ============================================================================');
     sourceFile.addStatements('// Entity types');
     sourceFile.addStatements('// ============================================================================\n');
@@ -22,44 +107,13 @@ export function generateTypesFile(tables) {
         }));
         sourceFile.addInterface(createInterface(table.name, properties));
     }
-    // Add section comment for filters
+    // Add section comment for filter types
     sourceFile.addStatements('\n// ============================================================================');
-    sourceFile.addStatements('// Filter types (shared)');
+    sourceFile.addStatements('// Filter types (shared PostGraphile filter interfaces)');
     sourceFile.addStatements('// ============================================================================\n');
-    // Add base filter types (using string concat for complex types - acceptable for static definitions)
-    const filterTypesContent = generateBaseFilterTypes();
-    // Extract just the interfaces part (skip the header)
-    const filterInterfaces = filterTypesContent
-        .split('\n')
-        .slice(6) // Skip header lines
-        .join('\n');
-    sourceFile.addStatements(filterInterfaces);
-    return getFormattedOutput(sourceFile);
-}
-/**
- * Generate a minimal entity type (just id and display fields)
- */
-export function generateMinimalEntityType(table) {
-    const project = createProject();
-    const sourceFile = createSourceFile(project, 'minimal.ts');
-    const scalarFields = getScalarFields(table);
-    // Find id and likely display fields
-    const displayFields = scalarFields.filter((f) => {
-        const name = f.name.toLowerCase();
-        return (name === 'id' ||
-            name === 'name' ||
-            name === 'title' ||
-            name === 'label' ||
-            name === 'email' ||
-            name.endsWith('name') ||
-            name.endsWith('title'));
-    });
-    // If no display fields found, take first 5 scalar fields
-    const fieldsToUse = displayFields.length > 0 ? displayFields : scalarFields.slice(0, 5);
-    const properties = fieldsToUse.map((field) => ({
-        name: field.name,
-        type: `${fieldTypeToTs(field.type)} | null`,
-    }));
-    sourceFile.addInterface(createInterface(`${table.name}Minimal`, properties));
+    // Generate all filter types
+    for (const { name, tsType, operators } of FILTER_CONFIGS) {
+        sourceFile.addInterface(createInterface(name, buildFilterProperties(tsType, operators)));
+    }
     return getFormattedOutput(sourceFile);
 }

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

@@ -134,8 +134,10 @@ export declare function gqlTypeToTs(gqlType: string, isArray?: boolean): string;
 export declare function fieldTypeToTs(fieldType: CleanFieldType): string;
 /**
  * Get the PostGraphile filter type for a GraphQL scalar
+ * @param gqlType - The GraphQL type string (e.g., "String", "UUID")
+ * @param isArray - Whether this is an array type
  */
-export declare function getScalarFilterType(gqlType: string): string | null;
+export declare function getScalarFilterType(gqlType: string, isArray?: boolean): string | null;
 /**
  * Check if a field is a relation field (not a scalar)
  */
@@ -145,7 +147,23 @@ export declare function isRelationField(fieldName: string, table: CleanTable): b
  */
 export declare function getScalarFields(table: CleanTable): CleanField[];
 /**
- * Get primary key field names
+ * Primary key field information
+ */
+export interface PrimaryKeyField {
+    /** Field name */
+    name: string;
+    /** GraphQL type (e.g., "UUID", "Int", "String") */
+    gqlType: string;
+    /** TypeScript type (e.g., "string", "number") */
+    tsType: string;
+}
+/**
+ * Get primary key field information from table constraints
+ * Returns array to support composite primary keys
+ */
+export declare function getPrimaryKeyInfo(table: CleanTable): PrimaryKeyField[];
+/**
+ * Get primary key field names (convenience wrapper)
  */
 export declare function getPrimaryKeyFields(table: CleanTable): string[];
 /**

package/esm/cli/codegen/utils.js

@@ -220,10 +220,12 @@ export function fieldTypeToTs(fieldType) {
 // ============================================================================
 /**
  * Get the PostGraphile filter type for a GraphQL scalar
+ * @param gqlType - The GraphQL type string (e.g., "String", "UUID")
+ * @param isArray - Whether this is an array type
  */
-export function getScalarFilterType(gqlType) {
+export function getScalarFilterType(gqlType, isArray = false) {
     const cleanType = gqlType.replace(/!/g, '');
-    return scalarToFilterType(cleanType);
+    return scalarToFilterType(cleanType, isArray);
 }
 // ============================================================================
 // Field filtering utilities
@@ -245,13 +247,35 @@ export function getScalarFields(table) {
     return table.fields.filter((f) => !isRelationField(f.name, table));
 }
 /**
- * Get primary key field names
+ * Get primary key field information from table constraints
+ * Returns array to support composite primary keys
  */
-export function getPrimaryKeyFields(table) {
+export function getPrimaryKeyInfo(table) {
     const pk = table.constraints?.primaryKey?.[0];
-    if (!pk)
-        return ['id']; // Default assumption
-    return pk.fields.map((f) => f.name);
+    if (!pk || pk.fields.length === 0) {
+        // Fallback: try to find 'id' field in table fields
+        const idField = table.fields.find(f => f.name.toLowerCase() === 'id');
+        if (idField) {
+            return [{
+                    name: idField.name,
+                    gqlType: idField.type.gqlType,
+                    tsType: fieldTypeToTs(idField.type),
+                }];
+        }
+        // Last resort: assume 'id' of type string (UUID)
+        return [{ name: 'id', gqlType: 'UUID', tsType: 'string' }];
+    }
+    return pk.fields.map((f) => ({
+        name: f.name,
+        gqlType: f.type.gqlType,
+        tsType: fieldTypeToTs(f.type),
+    }));
+}
+/**
+ * Get primary key field names (convenience wrapper)
+ */
+export function getPrimaryKeyFields(table) {
+    return getPrimaryKeyInfo(table).map((pk) => pk.name);
 }
 // ============================================================================
 // Query key generation

package/esm/cli/commands/generate-orm.js

@@ -111,16 +111,16 @@ export async function generateOrmCommand(options = {}) {
         }
     }
     // 7. Generate ORM code
-    log('Generating ORM client...');
+    console.log('Generating code...');
     const { files: generatedFiles, stats } = generateOrm({
         tables,
         customOperations: customOperationsData,
         config,
     });
-    log(`  Generated ${stats.tables} table models`);
-    log(`  Generated ${stats.customQueries} custom query operations`);
-    log(`  Generated ${stats.customMutations} custom mutation operations`);
-    log(`  Total files: ${stats.totalFiles}`);
+    console.log(`Generated ${stats.totalFiles} files`);
+    log(`  ${stats.tables} table models`);
+    log(`  ${stats.customQueries} custom query operations`);
+    log(`  ${stats.customMutations} custom mutation operations`);
     if (options.dryRun) {
         return {
             success: true,

package/esm/cli/commands/generate.d.ts

@@ -36,4 +36,7 @@ export interface WriteResult {
     filesWritten?: string[];
     errors?: string[];
 }
-export declare function writeGeneratedFiles(files: GeneratedFile[], outputDir: string, subdirs: string[]): Promise<WriteResult>;
+export interface WriteOptions {
+    showProgress?: boolean;
+}
+export declare function writeGeneratedFiles(files: GeneratedFile[], outputDir: string, subdirs: string[], options?: WriteOptions): Promise<WriteResult>;

package/esm/cli/commands/generate.js

@@ -112,17 +112,17 @@ export async function generateCommand(options = {}) {
         }
     }
     // 7. Generate code
-    log('Generating code...');
+    console.log('Generating code...');
     const { files: generatedFiles, stats } = generate({
         tables,
         customOperations: customOperationsData,
         config,
     });
-    log(`  Generated ${stats.queryHooks} table query hooks`);
-    log(`  Generated ${stats.mutationHooks} table mutation hooks`);
-    log(`  Generated ${stats.customQueryHooks} custom query hooks`);
-    log(`  Generated ${stats.customMutationHooks} custom mutation hooks`);
-    log(`  Total files: ${stats.totalFiles}`);
+    console.log(`Generated ${stats.totalFiles} files`);
+    log(`  ${stats.queryHooks} table query hooks`);
+    log(`  ${stats.mutationHooks} table mutation hooks`);
+    log(`  ${stats.customQueryHooks} custom query hooks`);
+    log(`  ${stats.customMutationHooks} custom mutation hooks`);
     if (options.dryRun) {
         return {
             success: true,
@@ -191,9 +191,12 @@ async function loadConfig(options) {
     const config = resolveConfig(mergedConfig);
     return { success: true, config };
 }
-export async function writeGeneratedFiles(files, outputDir, subdirs) {
+export async function writeGeneratedFiles(files, outputDir, subdirs, options = {}) {
+    const { showProgress = true } = options;
     const errors = [];
     const written = [];
+    const total = files.length;
+    const isTTY = process.stdout.isTTY;
     // Ensure output directory exists
     try {
         fs.mkdirSync(outputDir, { recursive: true });
@@ -219,8 +222,20 @@ export async function writeGeneratedFiles(files, outputDir, subdirs) {
     if (errors.length > 0) {
         return { success: false, errors };
     }
-    for (const file of files) {
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
         const filePath = path.join(outputDir, file.path);
+        // Show progress
+        if (showProgress) {
+            const progress = Math.round(((i + 1) / total) * 100);
+            if (isTTY) {
+                process.stdout.write(`\rWriting files: ${i + 1}/${total} (${progress}%)`);
+            }
+            else if (i % 100 === 0 || i === total - 1) {
+                // Non-TTY: periodic updates for CI/CD
+                console.log(`Writing files: ${i + 1}/${total}`);
+            }
+        }
         // Ensure parent directory exists
         const parentDir = path.dirname(filePath);
         try {
@@ -240,6 +255,10 @@ export async function writeGeneratedFiles(files, outputDir, subdirs) {
             errors.push(`Failed to write ${filePath}: ${message}`);
         }
     }
+    // Clear progress line
+    if (showProgress && isTTY) {
+        process.stdout.write('\r' + ' '.repeat(40) + '\r');
+    }
     return {
         success: errors.length === 0,
         filesWritten: written,