@constructive-io/graphql-codegen 2.22.1 → 2.23.1

package/esm/cli/commands/generate.js

@@ -1,20 +1,17 @@
 /**
- * Generate command - introspects endpoint and generates SDK
+ * Generate command - generates SDK from GraphQL schema
  *
  * This command:
- * 1. Fetches _meta query for table-based CRUD operations
- * 2. Fetches __schema introspection for ALL operations
- * 3. Filters out table operations from custom operations to avoid duplicates
- * 4. Generates hooks for both table CRUD and custom operations
+ * 1. Fetches schema from endpoint or loads from file
+ * 2. Infers table metadata from introspection (replaces _meta)
+ * 3. Generates hooks for both table CRUD and custom operations
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as prettier from 'prettier';
 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 { generate } from '../codegen';
 /**
@@ -32,110 +29,90 @@ export async function generateCommand(options = {}) {
         };
     }
     const config = configResult.config;
-    log(`  Endpoint: ${config.endpoint}`);
+    // Log source
+    if (config.schema) {
+        log(`  Schema: ${config.schema}`);
+    }
+    else {
+        log(`  Endpoint: ${config.endpoint}`);
+    }
     log(`  Output: ${config.output}`);
-    // 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 code
+    // 5. Generate code
     console.log('Generating code...');
-    const { files: generatedFiles, stats } = generate({
+    const { files: generatedFiles, stats: genStats } = generate({
         tables,
-        customOperations: customOperationsData,
+        customOperations: {
+            queries: customOperations.queries,
+            mutations: customOperations.mutations,
+            typeRegistry: customOperations.typeRegistry,
+        },
         config,
     });
-    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`);
+    console.log(`Generated ${genStats.totalFiles} files`);
+    log(`  ${genStats.queryHooks} table query hooks`);
+    log(`  ${genStats.mutationHooks} table mutation hooks`);
+    log(`  ${genStats.customQueryHooks} custom query hooks`);
+    log(`  ${genStats.customMutationHooks} custom mutation hooks`);
+    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, config.output, ['queries', 'mutations']);
+    const writeResult = await writeGeneratedFiles(generatedFiles, config.output, [
+        'queries',
+        'mutations',
+    ]);
     if (!writeResult.success) {
         return {
             success: false,
@@ -170,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,
@@ -181,10 +159,11 @@ async function loadConfig(options) {
         postgraphile: baseConfig.postgraphile,
         codegen: baseConfig.codegen,
     };
-    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/shared.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Shared Codegen Pipeline
+ *
+ * Consolidates the common logic between generate and generate-orm commands.
+ * Handles:
+ * - Schema fetching from source (endpoint or file)
+ * - Table inference from introspection
+ * - Operation transformation
+ * - Filtering
+ */
+import type { ResolvedConfig } from '../../types/config';
+import type { CleanTable, CleanOperation, TypeRegistry } from '../../types/schema';
+import type { SchemaSource } from '../introspect/source';
+export interface CodegenPipelineOptions {
+    /**
+     * Schema source (endpoint or file)
+     */
+    source: SchemaSource;
+    /**
+     * Resolved configuration
+     */
+    config: ResolvedConfig;
+    /**
+     * Enable verbose logging
+     */
+    verbose?: boolean;
+    /**
+     * Skip custom operations (only generate table CRUD)
+     */
+    skipCustomOperations?: boolean;
+}
+export interface CodegenPipelineResult {
+    /**
+     * Inferred table metadata
+     */
+    tables: CleanTable[];
+    /**
+     * Custom operations (queries and mutations not covered by tables)
+     */
+    customOperations: {
+        queries: CleanOperation[];
+        mutations: CleanOperation[];
+        typeRegistry: TypeRegistry;
+    };
+    /**
+     * Statistics about what was found
+     */
+    stats: {
+        totalTables: number;
+        filteredTables: number;
+        totalQueries: number;
+        totalMutations: number;
+        customQueries: number;
+        customMutations: number;
+    };
+}
+/**
+ * Run the unified codegen pipeline
+ *
+ * This replaces the duplicated logic in generate.ts and generate-orm.ts:
+ * 1. Fetch introspection from source (endpoint or file)
+ * 2. Infer tables from introspection (replaces _meta query)
+ * 3. Transform to operations
+ * 4. Filter by config
+ * 5. Separate table operations from custom operations
+ */
+export declare function runCodegenPipeline(options: CodegenPipelineOptions): Promise<CodegenPipelineResult>;
+/**
+ * Validate that tables were found
+ */
+export declare function validateTablesFound(tables: CleanTable[]): {
+    valid: boolean;
+    error?: string;
+};

package/esm/cli/commands/shared.js

@@ -0,0 +1,84 @@
+import { inferTablesFromIntrospection } from '../introspect/infer-tables';
+import { filterTables } from '../introspect/transform';
+import { transformSchemaToOperations, filterOperations, getTableOperationNames, getCustomOperations, } from '../introspect/transform-schema';
+// ============================================================================
+// Main Pipeline
+// ============================================================================
+/**
+ * Run the unified codegen pipeline
+ *
+ * This replaces the duplicated logic in generate.ts and generate-orm.ts:
+ * 1. Fetch introspection from source (endpoint or file)
+ * 2. Infer tables from introspection (replaces _meta query)
+ * 3. Transform to operations
+ * 4. Filter by config
+ * 5. Separate table operations from custom operations
+ */
+export async function runCodegenPipeline(options) {
+    const { source, config, verbose = false, skipCustomOperations = false, } = options;
+    const log = verbose ? console.log : () => { };
+    // 1. Fetch introspection from source
+    log(`Fetching schema from ${source.describe()}...`);
+    const { introspection } = await source.fetch();
+    // 2. Infer tables from introspection (replaces _meta)
+    log('Inferring table metadata from schema...');
+    let tables = inferTablesFromIntrospection(introspection);
+    const totalTables = tables.length;
+    log(`  Found ${totalTables} tables`);
+    // 3. Filter tables by config
+    tables = filterTables(tables, config.tables.include, config.tables.exclude);
+    const filteredTables = tables.length;
+    log(`  After filtering: ${filteredTables} tables`);
+    // 4. Transform introspection to operations
+    log('Transforming operations...');
+    const { queries: allQueries, mutations: allMutations, typeRegistry, } = transformSchemaToOperations(introspection);
+    const totalQueries = allQueries.length;
+    const totalMutations = allMutations.length;
+    log(`  Found ${totalQueries} queries and ${totalMutations} mutations total`);
+    // 5. Get table operation names for filtering custom ops
+    const tableOperationNames = getTableOperationNames(tables);
+    // 6. Filter and separate custom operations
+    let customQueries = [];
+    let customMutations = [];
+    if (!skipCustomOperations) {
+        // 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)
+        customQueries = getCustomOperations(filteredQueries, tableOperationNames);
+        customMutations = getCustomOperations(filteredMutations, tableOperationNames);
+        log(`  Custom operations: ${customQueries.length} queries, ${customMutations.length} mutations`);
+    }
+    return {
+        tables,
+        customOperations: {
+            queries: customQueries,
+            mutations: customMutations,
+            typeRegistry,
+        },
+        stats: {
+            totalTables,
+            filteredTables,
+            totalQueries,
+            totalMutations,
+            customQueries: customQueries.length,
+            customMutations: customMutations.length,
+        },
+    };
+}
+// ============================================================================
+// Validation Helpers
+// ============================================================================
+/**
+ * Validate that tables were found
+ */
+export function validateTablesFound(tables) {
+    if (tables.length === 0) {
+        return {
+            valid: false,
+            error: 'No tables found after filtering. Check your include/exclude patterns.',
+        };
+    }
+    return { valid: true };
+}

package/esm/cli/index.js

@@ -6,7 +6,7 @@ import { initCommand, findConfigFile, loadConfigFile } from './commands/init';
 import { generateCommand } from './commands/generate';
 import { generateOrmCommand } from './commands/generate-orm';
 import { startWatch } from './watch';
-import { resolveConfig } from '../types/config';
+import { resolveConfig, } from '../types/config';
 const program = new Command();
 /**
  * Load configuration for watch mode, merging CLI options with config file
@@ -21,7 +21,7 @@ async function loadWatchConfig(options) {
     if (configPath) {
         const loadResult = await loadConfigFile(configPath);
         if (!loadResult.success) {
-            console.error('✗', loadResult.error);
+            console.error('x', loadResult.error);
             return null;
         }
         baseConfig = loadResult.config;
@@ -42,21 +42,23 @@ async function loadWatchConfig(options) {
         watch: {
             ...baseConfig.watch,
             // CLI options override config
-            ...(options.pollInterval !== undefined && { pollInterval: options.pollInterval }),
+            ...(options.pollInterval !== undefined && {
+                pollInterval: options.pollInterval,
+            }),
             ...(options.debounce !== undefined && { debounce: options.debounce }),
             ...(options.touch !== undefined && { touchFile: options.touch }),
             ...(options.clear !== undefined && { clearScreen: options.clear }),
         },
     };
     if (!mergedConfig.endpoint) {
-        console.error('✗ No endpoint specified. Use --endpoint or create a config file with "graphql-codegen init".');
+        console.error('x No endpoint specified. Use --endpoint or create a config file with "graphql-codegen init".');
         return null;
     }
     return resolveConfig(mergedConfig);
 }
 program
     .name('graphql-codegen')
-    .description('CLI for generating GraphQL SDK from PostGraphile endpoints')
+    .description('CLI for generating GraphQL SDK from PostGraphile endpoints or schema files')
     .version('2.17.48');
 // Init command
 program
@@ -74,19 +76,20 @@ program
         output: options.output,
     });
     if (result.success) {
-        console.log('✓', result.message);
+        console.log('[ok]', result.message);
     }
     else {
-        console.error('✗', result.message);
+        console.error('x', result.message);
         process.exit(1);
     }
 });
 // Generate command
 program
     .command('generate')
-    .description('Generate SDK from GraphQL endpoint')
+    .description('Generate SDK from GraphQL endpoint or schema file')
     .option('-c, --config <path>', 'Path to config file')
     .option('-e, --endpoint <url>', 'GraphQL endpoint URL (overrides config)')
+    .option('-s, --schema <path>', 'Path to GraphQL schema file (.graphql)')
     .option('-o, --output <dir>', 'Output directory (overrides config)')
     .option('-a, --authorization <header>', 'Authorization header value')
     .option('-v, --verbose', 'Verbose output', false)
@@ -97,8 +100,17 @@ program
     .option('--touch <file>', 'File to touch on schema change')
     .option('--no-clear', 'Do not clear terminal on regeneration')
     .action(async (options) => {
-    // Watch mode
+    // Validate source options
+    if (options.endpoint && options.schema) {
+        console.error('x Cannot use both --endpoint and --schema. Choose one source.');
+        process.exit(1);
+    }
+    // Watch mode (only for endpoint)
     if (options.watch) {
+        if (options.schema) {
+            console.error('x Watch mode is only supported with --endpoint, not --schema.');
+            process.exit(1);
+        }
         const config = await loadWatchConfig(options);
         if (!config) {
             process.exit(1);
@@ -116,13 +128,14 @@ program
     const result = await generateCommand({
         config: options.config,
         endpoint: options.endpoint,
+        schema: options.schema,
         output: options.output,
         authorization: options.authorization,
         verbose: options.verbose,
         dryRun: options.dryRun,
     });
     if (result.success) {
-        console.log('✓', result.message);
+        console.log('[ok]', result.message);
         if (result.tables && result.tables.length > 0) {
             console.log('\nTables:');
             result.tables.forEach((t) => console.log(`  - ${t}`));
@@ -133,7 +146,7 @@ program
         }
     }
     else {
-        console.error('✗', result.message);
+        console.error('x', result.message);
         if (result.errors) {
             result.errors.forEach((e) => console.error('  -', e));
         }
@@ -143,9 +156,10 @@ program
 // Generate ORM command
 program
     .command('generate-orm')
-    .description('Generate Prisma-like ORM client from GraphQL endpoint')
+    .description('Generate Prisma-like ORM client from GraphQL endpoint or schema file')
     .option('-c, --config <path>', 'Path to config file')
     .option('-e, --endpoint <url>', 'GraphQL endpoint URL (overrides config)')
+    .option('-s, --schema <path>', 'Path to GraphQL schema file (.graphql)')
     .option('-o, --output <dir>', 'Output directory (overrides config)', './generated/orm')
     .option('-a, --authorization <header>', 'Authorization header value')
     .option('-v, --verbose', 'Verbose output', false)
@@ -157,8 +171,17 @@ program
     .option('--touch <file>', 'File to touch on schema change')
     .option('--no-clear', 'Do not clear terminal on regeneration')
     .action(async (options) => {
-    // Watch mode
+    // Validate source options
+    if (options.endpoint && options.schema) {
+        console.error('x Cannot use both --endpoint and --schema. Choose one source.');
+        process.exit(1);
+    }
+    // Watch mode (only for endpoint)
     if (options.watch) {
+        if (options.schema) {
+            console.error('x Watch mode is only supported with --endpoint, not --schema.');
+            process.exit(1);
+        }
         const config = await loadWatchConfig(options);
         if (!config) {
             process.exit(1);
@@ -177,6 +200,7 @@ program
     const result = await generateOrmCommand({
         config: options.config,
         endpoint: options.endpoint,
+        schema: options.schema,
         output: options.output,
         authorization: options.authorization,
         verbose: options.verbose,
@@ -184,7 +208,7 @@ program
         skipCustomOperations: options.skipCustomOperations,
     });
     if (result.success) {
-        console.log('✓', result.message);
+        console.log('[ok]', result.message);
         if (result.tables && result.tables.length > 0) {
             console.log('\nTables:');
             result.tables.forEach((t) => console.log(`  - ${t}`));
@@ -203,54 +227,60 @@ program
         }
     }
     else {
-        console.error('✗', result.message);
+        console.error('x', result.message);
         if (result.errors) {
             result.errors.forEach((e) => console.error('  -', e));
         }
         process.exit(1);
     }
 });
-// Introspect command (for debugging)
+// Introspect command (for debugging) - uses the new inference system
 program
     .command('introspect')
-    .description('Introspect a GraphQL endpoint and print table info')
-    .requiredOption('-e, --endpoint <url>', 'GraphQL endpoint URL')
+    .description('Introspect a GraphQL endpoint or schema file and print table info')
+    .option('-e, --endpoint <url>', 'GraphQL endpoint URL')
+    .option('-s, --schema <path>', 'Path to GraphQL schema file (.graphql)')
     .option('-a, --authorization <header>', 'Authorization header value')
     .option('--json', 'Output as JSON', false)
     .action(async (options) => {
-    const { fetchMeta, validateEndpoint } = await import('./introspect/fetch-meta');
-    const { transformMetaToCleanTables, getTableNames } = await import('./introspect/transform');
-    // Validate endpoint
-    const validation = validateEndpoint(options.endpoint);
-    if (!validation.valid) {
-        console.error('✗ Invalid endpoint:', validation.error);
+    // Validate source options
+    if (!options.endpoint && !options.schema) {
+        console.error('x Either --endpoint or --schema must be provided.');
         process.exit(1);
     }
-    console.log('Fetching schema from', options.endpoint, '...');
-    const result = await fetchMeta({
-        endpoint: options.endpoint,
-        authorization: options.authorization,
-    });
-    if (!result.success) {
-        console.error('✗ Failed to fetch schema:', result.error);
+    if (options.endpoint && options.schema) {
+        console.error('x Cannot use both --endpoint and --schema. Choose one source.');
         process.exit(1);
     }
-    const tables = transformMetaToCleanTables(result.data);
-    const tableNames = getTableNames(tables);
-    if (options.json) {
-        console.log(JSON.stringify(tables, null, 2));
-    }
-    else {
-        console.log(`\n✓ Found ${tables.length} tables:\n`);
-        tableNames.forEach((name) => {
-            const table = tables.find((t) => t.name === name);
-            const fieldCount = table.fields.length;
-            const relationCount = table.relations.belongsTo.length +
-                table.relations.hasOne.length +
-                table.relations.hasMany.length +
-                table.relations.manyToMany.length;
-            console.log(`  ${name} (${fieldCount} fields, ${relationCount} relations)`);
+    const { createSchemaSource } = await import('./introspect/source');
+    const { inferTablesFromIntrospection } = await import('./introspect/infer-tables');
+    try {
+        const source = createSchemaSource({
+            endpoint: options.endpoint,
+            schema: options.schema,
+            authorization: options.authorization,
         });
+        console.log('Fetching schema from', source.describe(), '...');
+        const { introspection } = await source.fetch();
+        const tables = inferTablesFromIntrospection(introspection);
+        if (options.json) {
+            console.log(JSON.stringify(tables, null, 2));
+        }
+        else {
+            console.log(`\n[ok] Found ${tables.length} tables:\n`);
+            tables.forEach((table) => {
+                const fieldCount = table.fields.length;
+                const relationCount = table.relations.belongsTo.length +
+                    table.relations.hasOne.length +
+                    table.relations.hasMany.length +
+                    table.relations.manyToMany.length;
+                console.log(`  ${table.name} (${fieldCount} fields, ${relationCount} relations)`);
+            });
+        }
+    }
+    catch (err) {
+        console.error('x Failed to introspect schema:', err instanceof Error ? err.message : err);
+        process.exit(1);
     }
 });
 program.parse();

package/esm/cli/introspect/index.d.ts

@@ -1,8 +1,11 @@
 /**
  * Introspection module exports
  */
-export { META_QUERY } from './meta-query';
-export type { MetaQueryResponse, MetaTable, MetaField, MetaFieldType, MetaConstraint, MetaForeignKeyConstraint, MetaTableQuery, MetaTableInflection, MetaBelongsToRelation, MetaHasRelation, MetaManyToManyRelation, MetaTableRelations, } from './meta-query';
-export { fetchMeta, validateEndpoint } from './fetch-meta';
-export type { FetchMetaOptions, FetchMetaResult } from './fetch-meta';
-export { transformMetaToCleanTables, getTableNames, findTable, filterTables, } from './transform';
+export { inferTablesFromIntrospection } from './infer-tables';
+export type { InferTablesOptions } from './infer-tables';
+export { singularize, pluralize } from 'inflekt';
+export { createSchemaSource, validateSourceOptions, EndpointSchemaSource, FileSchemaSource, SchemaSourceError, } from './source';
+export type { SchemaSource, SchemaSourceResult, CreateSchemaSourceOptions, } from './source';
+export { fetchSchema } from './fetch-schema';
+export type { FetchSchemaOptions, FetchSchemaResult } from './fetch-schema';
+export { getTableNames, findTable, filterTables } from './transform';

package/esm/cli/introspect/index.js

@@ -1,6 +1,13 @@
 /**
  * Introspection module exports
  */
-export { META_QUERY } from './meta-query';
-export { fetchMeta, validateEndpoint } from './fetch-meta';
-export { transformMetaToCleanTables, getTableNames, findTable, filterTables, } from './transform';
+// Table inference from introspection
+export { inferTablesFromIntrospection } from './infer-tables';
+// Pluralization utilities (from inflekt)
+export { singularize, pluralize } from 'inflekt';
+// Schema sources
+export { createSchemaSource, validateSourceOptions, EndpointSchemaSource, FileSchemaSource, SchemaSourceError, } from './source';
+// Schema fetching (still used by watch mode)
+export { fetchSchema } from './fetch-schema';
+// Transform utilities (only filterTables, getTableNames, findTable are still useful)
+export { getTableNames, findTable, filterTables } from './transform';