@constructive-io/graphql-codegen 2.22.1 → 2.23.0

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

@@ -1,12 +1,18 @@
 import { createProject, createSourceFile, getMinimalFormattedOutput, createFileHeader, createInterface, createTypeAlias, addSectionComment, } from '../ts-ast';
-import { getTableNames, getFilterTypeName, getOrderByTypeName, isRelationField, } from '../utils';
+import { getTableNames, getFilterTypeName, getConditionTypeName, getOrderByTypeName, isRelationField, } from '../utils';
+import { pluralize } from '../../introspect/pluralize';
 import { getTypeBaseName } from '../type-resolver';
 import { scalarToTsType, scalarToFilterType } from '../scalars';
 // ============================================================================
 // Constants
 // ============================================================================
 /** Fields excluded from Create/Update inputs (auto-generated or system fields) */
-const EXCLUDED_MUTATION_FIELDS = ['id', 'createdAt', 'updatedAt', 'nodeId'];
+const EXCLUDED_MUTATION_FIELDS = [
+    'id',
+    'createdAt',
+    'updatedAt',
+    'nodeId',
+];
 // ============================================================================
 // Type Conversion Utilities
 // ============================================================================
@@ -53,18 +59,58 @@ function isRequired(typeRef) {
 }
 /** Configuration for all scalar filter types - matches PostGraphile's generated filters */
 const SCALAR_FILTER_CONFIGS = [
-    { 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: '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: '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: 'InternetAddressFilter',
+        tsType: 'string',
+        operators: ['equality', 'distinct', 'inArray', 'comparison', 'inet'],
+    },
     { name: 'FullTextFilter', tsType: 'string', operators: ['fulltext'] },
 ];
 /**
@@ -224,7 +270,15 @@ function getRelatedTypeName(tableName, tableByName) {
 }
 function getRelatedOrderByName(tableName, tableByName) {
     const relatedTable = tableByName.get(tableName);
-    return relatedTable ? getOrderByTypeName(relatedTable) : `${tableName}sOrderBy`;
+    if (relatedTable) {
+        return getOrderByTypeName(relatedTable);
+    }
+    // For ManyToMany connection types, don't pluralize - just append OrderBy
+    // These types already have a fixed suffix pattern like "UserUsersByFooManyToMany"
+    if (tableName.endsWith('ManyToMany')) {
+        return `${tableName}OrderBy`;
+    }
+    return `${pluralize(tableName)}OrderBy`;
 }
 function getRelatedFilterName(tableName, tableByName) {
     const relatedTable = tableByName.get(tableName);
@@ -405,6 +459,39 @@ function addTableFilterTypes(sourceFile, tables) {
     }
 }
 // ============================================================================
+// Condition Types Generator (AST-based)
+// ============================================================================
+/**
+ * Build properties for a table condition interface
+ * Condition types are simpler than Filter types - they use direct value equality
+ */
+function buildTableConditionProperties(table) {
+    const properties = [];
+    for (const field of table.fields) {
+        const fieldType = typeof field.type === 'string' ? field.type : field.type.gqlType;
+        if (isRelationField(field.name, table))
+            continue;
+        // Condition types use the raw scalar type (nullable)
+        const tsType = scalarToTsType(fieldType, { unknownScalar: 'unknown' });
+        properties.push({
+            name: field.name,
+            type: `${tsType} | null`,
+            optional: true,
+        });
+    }
+    return properties;
+}
+/**
+ * Add table condition types
+ */
+function addTableConditionTypes(sourceFile, tables) {
+    addSectionComment(sourceFile, 'Table Condition Types');
+    for (const table of tables) {
+        const conditionName = getConditionTypeName(table);
+        sourceFile.addInterface(createInterface(conditionName, buildTableConditionProperties(table)));
+    }
+}
+// ============================================================================
 // OrderBy Types Generator (AST-based)
 // ============================================================================
 /**
@@ -488,7 +575,11 @@ function buildPatchProperties(table) {
             continue;
         const fieldType = typeof field.type === 'string' ? field.type : field.type.gqlType;
         const tsType = scalarToInputTs(fieldType);
-        properties.push({ name: field.name, type: `${tsType} | null`, optional: true });
+        properties.push({
+            name: field.name,
+            type: `${tsType} | null`,
+            optional: true,
+        });
     }
     return properties;
 }
@@ -602,7 +693,9 @@ function addCustomInputTypes(sourceFile, typeRegistry, usedInputTypes, tableCrud
                 properties.push({ name: field.name, type: tsType, optional });
                 // Follow nested Input types
                 const baseType = getTypeBaseName(field.type);
-                if (baseType && baseType.endsWith('Input') && !generatedTypes.has(baseType)) {
+                if (baseType &&
+                    baseType.endsWith('Input') &&
+                    !generatedTypes.has(baseType)) {
                     typesToGenerate.add(baseType);
                 }
             }
@@ -628,7 +721,8 @@ export function collectPayloadTypeNames(operations) {
     const payloadTypes = new Set();
     for (const op of operations) {
         const baseName = getTypeBaseName(op.returnType);
-        if (baseName && (baseName.endsWith('Payload') || !baseName.endsWith('Connection'))) {
+        if (baseName &&
+            (baseName.endsWith('Payload') || !baseName.endsWith('Connection'))) {
             payloadTypes.add(baseName);
         }
     }
@@ -642,8 +736,21 @@ function addPayloadTypes(sourceFile, typeRegistry, usedPayloadTypes, alreadyGene
     const generatedTypes = new Set(alreadyGeneratedTypes);
     const typesToGenerate = new Set(Array.from(usedPayloadTypes));
     const skipTypes = new Set([
-        'String', 'Int', 'Float', 'Boolean', 'ID', 'UUID', 'Datetime', 'Date',
-        'Time', 'JSON', 'BigInt', 'BigFloat', 'Cursor', 'Query', 'Mutation',
+        'String',
+        'Int',
+        'Float',
+        'Boolean',
+        'ID',
+        'UUID',
+        'Datetime',
+        'Date',
+        'Time',
+        'JSON',
+        'BigInt',
+        'BigFloat',
+        'Cursor',
+        'Query',
+        'Mutation',
     ]);
     // Process all types - no artificial limit
     while (typesToGenerate.size > 0) {
@@ -674,7 +781,9 @@ function addPayloadTypes(sourceFile, typeRegistry, usedPayloadTypes, alreadyGene
                 optional: isNullable,
             });
             // Follow nested OBJECT types
-            if (baseType && !generatedTypes.has(baseType) && !skipTypes.has(baseType)) {
+            if (baseType &&
+                !generatedTypes.has(baseType) &&
+                !skipTypes.has(baseType)) {
                 const nestedType = typeRegistry.get(baseType);
                 if (nestedType?.kind === 'OBJECT') {
                     typesToGenerate.add(baseType);
@@ -728,6 +837,8 @@ export function generateInputTypesFile(typeRegistry, usedInputTypes, tables, use
         addEntitySelectTypes(sourceFile, tables, tableByName);
         // 4. Table filter types
         addTableFilterTypes(sourceFile, tables);
+        // 4b. Table condition types (simple equality filter)
+        addTableConditionTypes(sourceFile, tables);
         // 5. OrderBy types
         addOrderByTypes(sourceFile, tables);
         // 6. CRUD input types

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

@@ -1,5 +1,5 @@
 import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, } from '../ts-ast';
-import { getTableNames, getOrderByTypeName, getFilterTypeName, lcFirst } from '../utils';
+import { getTableNames, getOrderByTypeName, getFilterTypeName, lcFirst, } from '../utils';
 /**
  * Generate a model class file for a table
  */
@@ -120,7 +120,8 @@ export function generateModelFile(table, _useSharedTypes) {
         before: args?.before,
         offset: args?.offset,
       },
-      '${whereTypeName}'
+      '${whereTypeName}',
+      '${orderByTypeName}'
     );
     return new QueryBuilder({
       client: this.client,

package/esm/cli/codegen/orm/query-builder.d.ts

@@ -105,7 +105,7 @@ export declare function buildFindManyDocument(operationName: string, queryField:
     after?: string;
     before?: string;
     offset?: number;
-}, filterTypeName: string): {
+}, filterTypeName: string, orderByTypeName: string): {
     document: string;
     variables: Record<string, unknown>;
 };

package/esm/cli/codegen/orm/query-builder.js

@@ -164,7 +164,7 @@ export function buildSelections(select, fieldMeta) {
 /**
  * Build a findMany query document
  */
-export function buildFindManyDocument(operationName, queryField, select, args, filterTypeName) {
+export function buildFindManyDocument(operationName, queryField, select, args, filterTypeName, orderByTypeName) {
     const selections = select ? buildSelections(select) : 'id';
     // Build variable definitions and query arguments
     const varDefs = [];
@@ -176,7 +176,7 @@ export function buildFindManyDocument(operationName, queryField, select, args, f
         variables.where = args.where;
     }
     if (args.orderBy && args.orderBy.length > 0) {
-        varDefs.push(`$orderBy: [${operationName}OrderBy!]`);
+        varDefs.push(`$orderBy: [${orderByTypeName}!]`);
         queryArgs.push('orderBy: $orderBy');
         variables.orderBy = args.orderBy;
     }

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

@@ -1,6 +1,6 @@
 import { createProject, createSourceFile, getMinimalFormattedOutput, createFileHeader, createInterface, createTypeAlias, addSectionComment, } from './ts-ast';
 import { getTypeBaseName } from './type-resolver';
-import { scalarToTsType, SCALAR_NAMES, BASE_FILTER_TYPE_NAMES } from './scalars';
+import { scalarToTsType, SCALAR_NAMES, BASE_FILTER_TYPE_NAMES, } from './scalars';
 // ============================================================================
 // Constants
 // ============================================================================
@@ -26,13 +26,13 @@ const SKIP_TYPES = new Set([
 /**
  * Type name patterns to skip (regex patterns)
  *
- * Note: We intentionally DO NOT skip Connection, Edge, Filter, or Patch types
- * because they may be referenced by custom operations or payload types.
- * Only skip Condition and OrderBy which are typically not needed.
+ * 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 = [
-    /Condition$/, // e.g., UserCondition (filter conditions are separate)
-    /OrderBy$/, // e.g., UsersOrderBy (ordering is handled separately)
+// Currently no patterns are skipped - all types may be needed by custom operations
 ];
 // ============================================================================
 // Type Conversion Utilities

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

@@ -101,9 +101,14 @@ export declare function getDeleteMutationName(table: CleanTable): string;
 export declare function getFilterTypeName(table: CleanTable): string;
 /**
  * Get PostGraphile OrderBy enum type name
- * e.g., "CarsOrderBy"
+ * e.g., "CarsOrderBy", "AddressesOrderBy"
  */
 export declare function getOrderByTypeName(table: CleanTable): string;
+/**
+ * Get PostGraphile Condition type name (simple equality filter)
+ * e.g., "CarCondition", "AddressCondition"
+ */
+export declare function getConditionTypeName(table: CleanTable): string;
 /**
  * Get PostGraphile create input type name
  * e.g., "CreateCarInput"

package/esm/cli/codegen/utils.js

@@ -1,4 +1,5 @@
 import { scalarToTsType, scalarToFilterType } from './scalars';
+import { pluralize } from '../introspect/pluralize';
 // ============================================================================
 // String manipulation
 // ============================================================================
@@ -36,7 +37,9 @@ export function toScreamingSnake(str) {
 export function getTableNames(table) {
     const typeName = table.name;
     const singularName = table.inflection?.tableFieldName || lcFirst(typeName);
-    const pluralName = table.query?.all || table.inflection?.allRows || singularName + 's';
+    const pluralName = table.query?.all ||
+        table.inflection?.allRows ||
+        lcFirst(pluralize(typeName));
     const pluralTypeName = ucFirst(pluralName);
     return {
         typeName,
@@ -125,13 +128,15 @@ export function getDeleteMutationFileName(table) {
  * Uses inflection from _meta, falls back to convention
  */
 export function getAllRowsQueryName(table) {
-    return table.query?.all || table.inflection?.allRows || lcFirst(table.name) + 's';
+    return (table.query?.all ||
+        table.inflection?.allRows ||
+        lcFirst(pluralize(table.name)));
 }
 /**
  * Get the GraphQL query name for fetching single row
  */
 export function getSingleRowQueryName(table) {
-    return table.query?.one || table.inflection?.tableFieldName || lcFirst(table.name);
+    return (table.query?.one || table.inflection?.tableFieldName || lcFirst(table.name));
 }
 /**
  * Get the GraphQL mutation name for creating
@@ -163,10 +168,17 @@ export function getFilterTypeName(table) {
 }
 /**
  * Get PostGraphile OrderBy enum type name
- * e.g., "CarsOrderBy"
+ * e.g., "CarsOrderBy", "AddressesOrderBy"
  */
 export function getOrderByTypeName(table) {
-    return table.inflection?.orderByType || `${table.name}sOrderBy`;
+    return table.inflection?.orderByType || `${pluralize(table.name)}OrderBy`;
+}
+/**
+ * Get PostGraphile Condition type name (simple equality filter)
+ * e.g., "CarCondition", "AddressCondition"
+ */
+export function getConditionTypeName(table) {
+    return table.inflection?.conditionType || `${table.name}Condition`;
 }
 /**
  * Get PostGraphile create input type name
@@ -254,13 +266,15 @@ export function getPrimaryKeyInfo(table) {
     const pk = table.constraints?.primaryKey?.[0];
     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');
+        const idField = table.fields.find((f) => f.name.toLowerCase() === 'id');
         if (idField) {
-            return [{
+            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' }];

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

@@ -1,9 +1,9 @@
 /**
- * Generate ORM command - generates Prisma-like ORM client
+ * Generate ORM command - generates Prisma-like ORM client from GraphQL schema
  *
  * This command:
- * 1. Fetches _meta query for table-based CRUD operations
- * 2. Fetches __schema introspection for custom operations
+ * 1. Fetches schema from endpoint or loads from file
+ * 2. Infers table metadata from introspection (replaces _meta)
  * 3. Generates a Prisma-like ORM client with fluent API
  */
 export interface GenerateOrmOptions {
@@ -11,6 +11,8 @@ export interface GenerateOrmOptions {
     config?: string;
     /** GraphQL endpoint URL (overrides config) */
     endpoint?: string;
+    /** Path to GraphQL schema file (.graphql) */
+    schema?: string;
     /** Output directory (overrides config) */
     output?: string;
     /** Authorization header */

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

@@ -1,16 +1,14 @@
 /**
- * Generate ORM command - generates Prisma-like ORM client
+ * Generate ORM command - generates Prisma-like ORM client from GraphQL schema
  *
  * This command:
- * 1. Fetches _meta query for table-based CRUD operations
- * 2. Fetches __schema introspection for custom operations
+ * 1. Fetches schema from endpoint or loads from file
+ * 2. Infers table metadata from introspection (replaces _meta)
  * 3. Generates a Prisma-like ORM client with fluent API
  */
 import { resolveConfig } from '../../types/config';
-import { fetchMeta, validateEndpoint } from '../introspect/fetch-meta';
-import { fetchSchema } from '../introspect/fetch-schema';
-import { transformMetaToCleanTables, filterTables, } from '../introspect/transform';
-import { transformSchemaToOperations, filterOperations, getTableOperationNames, getCustomOperations, } from '../introspect/transform-schema';
+import { createSchemaSource, validateSourceOptions, } from '../introspect/source';
+import { runCodegenPipeline, validateTablesFound } from './shared';
 import { findConfigFile, loadConfigFile } from './init';
 import { writeGeneratedFiles } from './generate';
 import { generateOrm } from '../codegen/orm';
@@ -31,109 +29,90 @@ export async function generateOrmCommand(options = {}) {
     const config = configResult.config;
     // Use ORM output directory if specified, otherwise default
     const outputDir = options.output || config.orm?.output || './generated/orm';
-    log(`  Endpoint: ${config.endpoint}`);
+    // Log source
+    if (config.schema) {
+        log(`  Schema: ${config.schema}`);
+    }
+    else {
+        log(`  Endpoint: ${config.endpoint}`);
+    }
     log(`  Output: ${outputDir}`);
-    // 2. Validate endpoint
-    const endpointValidation = validateEndpoint(config.endpoint);
-    if (!endpointValidation.valid) {
+    // 2. Create schema source
+    const sourceValidation = validateSourceOptions({
+        endpoint: config.endpoint || undefined,
+        schema: config.schema || undefined,
+    });
+    if (!sourceValidation.valid) {
         return {
             success: false,
-            message: `Invalid endpoint: ${endpointValidation.error}`,
+            message: sourceValidation.error,
         };
     }
-    // Build authorization header if provided
-    const authHeader = options.authorization || config.headers['Authorization'];
-    // 3. Fetch _meta for table-based operations
-    log('Fetching schema metadata (_meta)...');
-    const metaResult = await fetchMeta({
-        endpoint: config.endpoint,
-        authorization: authHeader,
+    const source = createSchemaSource({
+        endpoint: config.endpoint || undefined,
+        schema: config.schema || undefined,
+        authorization: options.authorization || config.headers['Authorization'],
         headers: config.headers,
-        timeout: 30000,
     });
-    if (!metaResult.success) {
+    // 3. Run the codegen pipeline
+    let pipelineResult;
+    try {
+        pipelineResult = await runCodegenPipeline({
+            source,
+            config,
+            verbose: options.verbose,
+            skipCustomOperations: options.skipCustomOperations,
+        });
+    }
+    catch (err) {
         return {
             success: false,
-            message: `Failed to fetch _meta: ${metaResult.error}`,
+            message: `Failed to fetch schema: ${err instanceof Error ? err.message : 'Unknown error'}`,
         };
     }
-    // 4. Transform to CleanTable[]
-    log('Transforming table schema...');
-    let tables = transformMetaToCleanTables(metaResult.data);
-    log(`  Found ${tables.length} tables`);
-    // 5. Filter tables
-    tables = filterTables(tables, config.tables.include, config.tables.exclude);
-    log(`  After filtering: ${tables.length} tables`);
-    if (tables.length === 0) {
+    const { tables, customOperations, stats } = pipelineResult;
+    // 4. Validate tables found
+    const tablesValidation = validateTablesFound(tables);
+    if (!tablesValidation.valid) {
         return {
             success: false,
-            message: 'No tables found after filtering. Check your include/exclude patterns.',
+            message: tablesValidation.error,
         };
     }
-    // Get table operation names for filtering custom operations
-    const tableOperationNames = getTableOperationNames(tables);
-    // 6. Fetch __schema for custom operations (unless skipped)
-    let customQueries = [];
-    let customMutations = [];
-    let customOperationsData;
-    if (!options.skipCustomOperations) {
-        log('Fetching schema introspection (__schema)...');
-        const schemaResult = await fetchSchema({
-            endpoint: config.endpoint,
-            authorization: authHeader,
-            headers: config.headers,
-            timeout: 30000,
-        });
-        if (schemaResult.success && schemaResult.data) {
-            log('Transforming custom operations...');
-            // Transform to CleanOperation[]
-            const { queries: allQueries, mutations: allMutations, typeRegistry } = transformSchemaToOperations(schemaResult.data);
-            log(`  Found ${allQueries.length} queries and ${allMutations.length} mutations total`);
-            // Filter by config include/exclude
-            const filteredQueries = filterOperations(allQueries, config.queries.include, config.queries.exclude);
-            const filteredMutations = filterOperations(allMutations, config.mutations.include, config.mutations.exclude);
-            log(`  After config filtering: ${filteredQueries.length} queries, ${filteredMutations.length} mutations`);
-            // Remove table operations (already handled by table generators)
-            const customQueriesOps = getCustomOperations(filteredQueries, tableOperationNames);
-            const customMutationsOps = getCustomOperations(filteredMutations, tableOperationNames);
-            log(`  Custom operations: ${customQueriesOps.length} queries, ${customMutationsOps.length} mutations`);
-            customQueries = customQueriesOps.map((q) => q.name);
-            customMutations = customMutationsOps.map((m) => m.name);
-            customOperationsData = {
-                queries: customQueriesOps,
-                mutations: customMutationsOps,
-                typeRegistry,
-            };
-        }
-        else {
-            log(`  Warning: Could not fetch __schema: ${schemaResult.error}`);
-            log('  Continuing with table-only generation...');
-        }
-    }
-    // 7. Generate ORM code
+    // 5. Generate ORM code
     console.log('Generating code...');
-    const { files: generatedFiles, stats } = generateOrm({
+    const { files: generatedFiles, stats: genStats } = generateOrm({
         tables,
-        customOperations: customOperationsData,
+        customOperations: {
+            queries: customOperations.queries,
+            mutations: customOperations.mutations,
+            typeRegistry: customOperations.typeRegistry,
+        },
         config,
     });
-    console.log(`Generated ${stats.totalFiles} files`);
-    log(`  ${stats.tables} table models`);
-    log(`  ${stats.customQueries} custom query operations`);
-    log(`  ${stats.customMutations} custom mutation operations`);
+    console.log(`Generated ${genStats.totalFiles} files`);
+    log(`  ${genStats.tables} table models`);
+    log(`  ${genStats.customQueries} custom query operations`);
+    log(`  ${genStats.customMutations} custom mutation operations`);
+    const customQueries = customOperations.queries.map((q) => q.name);
+    const customMutations = customOperations.mutations.map((m) => m.name);
     if (options.dryRun) {
         return {
             success: true,
-            message: `Dry run complete. Would generate ${generatedFiles.length} files for ${tables.length} tables and ${customQueries.length + customMutations.length} custom operations.`,
+            message: `Dry run complete. Would generate ${generatedFiles.length} files for ${tables.length} tables and ${stats.customQueries + stats.customMutations} custom operations.`,
             tables: tables.map((t) => t.name),
             customQueries,
             customMutations,
             filesWritten: generatedFiles.map((f) => f.path),
         };
     }
-    // 8. Write files
+    // 6. Write files
     log('Writing files...');
-    const writeResult = await writeGeneratedFiles(generatedFiles, outputDir, ['models', 'query', 'mutation']);
+    const writeResult = await writeGeneratedFiles(generatedFiles, outputDir, [
+        'models',
+        'query',
+        'mutation',
+    ]);
     if (!writeResult.success) {
         return {
             success: false,
@@ -168,7 +147,8 @@ async function loadConfig(options) {
     }
     // Override with CLI options
     const mergedConfig = {
-        endpoint: options.endpoint || baseConfig.endpoint || '',
+        endpoint: options.endpoint || baseConfig.endpoint,
+        schema: options.schema || baseConfig.schema,
         output: options.output || baseConfig.output,
         headers: baseConfig.headers,
         tables: baseConfig.tables,
@@ -180,10 +160,11 @@ async function loadConfig(options) {
         codegen: baseConfig.codegen,
         orm: baseConfig.orm,
     };
-    if (!mergedConfig.endpoint) {
+    // Validate at least one source is provided
+    if (!mergedConfig.endpoint && !mergedConfig.schema) {
         return {
             success: false,
-            error: 'No endpoint specified. Use --endpoint or create a config file with "graphql-codegen init".',
+            error: 'No source specified. Use --endpoint or --schema, or create a config file with "graphql-codegen init".',
         };
     }
     // Resolve with defaults

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

@@ -3,6 +3,8 @@ export interface GenerateOptions {
     config?: string;
     /** GraphQL endpoint URL (overrides config) */
     endpoint?: string;
+    /** Path to GraphQL schema file (.graphql) */
+    schema?: string;
     /** Output directory (overrides config) */
     output?: string;
     /** Authorization header */