@constructive-io/graphql-codegen 2.32.0 → 3.0.0

package/{cli/commands/init.js → core/config/loader.js}

@@ -33,95 +33,26 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initCommand = initCommand;
+exports.CONFIG_FILENAME = void 0;
 exports.findConfigFile = findConfigFile;
 exports.loadConfigFile = loadConfigFile;
 /**
- * Init command - creates a new graphql-codegen configuration file
+ * Configuration file loading utilities
+ *
+ * Pure functions for finding and loading graphql-codegen configuration files.
+ * These are core utilities that can be used programmatically or by the CLI.
  */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const jiti_1 = require("jiti");
-const CONFIG_FILENAME = 'graphql-codegen.config.ts';
-const CONFIG_TEMPLATE = `import { defineConfig } from '@constructive-io/graphql-codegen';
-
-export default defineConfig({
-  // GraphQL endpoint URL (PostGraphile with _meta plugin)
-  endpoint: '{{ENDPOINT}}',
-
-  // Output directory for generated files
-  output: '{{OUTPUT}}',
-
-  // Optional: Multi-target config (use instead of endpoint/output)
-  // defaults: {
-  //   headers: { Authorization: 'Bearer YOUR_TOKEN' },
-  // },
-  // targets: {
-  //   public: { endpoint: 'https://api.example.com/graphql', output: './generated/public' },
-  //   admin: { schema: './admin.schema.graphql', output: './generated/admin' },
-  // },
-
-  // Optional: Tables to include/exclude (supports glob patterns)
-  // tables: {
-  //   include: ['*'],
-  //   exclude: ['_*', 'pg_*'],
-  // },
-
-  // Optional: Authorization header for authenticated endpoints
-  // headers: {
-  //   Authorization: 'Bearer YOUR_TOKEN',
-  // },
-
-  // Optional: Watch mode settings (in-memory caching, no file I/O)
-  // watch: {
-  //   pollInterval: 3000,  // ms
-  //   debounce: 800,       // ms
-  //   clearScreen: true,
-  //   touchFile: '.trigger',  // Optional: file to touch on change
-  // },
-});
-`;
-/**
- * Execute the init command
- */
-async function initCommand(options = {}) {
-    const { directory = process.cwd(), force = false, endpoint = '', output = './generated', } = options;
-    const configPath = path.join(directory, CONFIG_FILENAME);
-    // Check if config already exists
-    if (fs.existsSync(configPath) && !force) {
-        return {
-            success: false,
-            message: `Configuration file already exists: ${configPath}\nUse --force to overwrite.`,
-        };
-    }
-    // Generate config content
-    const content = CONFIG_TEMPLATE.replace('{{ENDPOINT}}', endpoint || 'http://localhost:5000/graphql').replace('{{OUTPUT}}', output);
-    try {
-        // Ensure directory exists
-        fs.mkdirSync(directory, { recursive: true });
-        // Write config file
-        fs.writeFileSync(configPath, content, 'utf-8');
-        return {
-            success: true,
-            message: `Created configuration file: ${configPath}`,
-            configPath,
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : 'Unknown error';
-        return {
-            success: false,
-            message: `Failed to create configuration file: ${message}`,
-        };
-    }
-}
+exports.CONFIG_FILENAME = 'graphql-codegen.config.ts';
 /**
  * Find the nearest config file by walking up directories
  */
 function findConfigFile(startDir = process.cwd()) {
     let currentDir = startDir;
     while (true) {
-        const configPath = path.join(currentDir, CONFIG_FILENAME);
+        const configPath = path.join(currentDir, exports.CONFIG_FILENAME);
         if (fs.existsSync(configPath)) {
             return configPath;
         }
@@ -163,24 +94,6 @@ async function loadConfigFile(configPath) {
                 error: 'Config file must export a configuration object',
             };
         }
-        const hasEndpoint = 'endpoint' in config;
-        const hasSchema = 'schema' in config;
-        const hasTargets = 'targets' in config;
-        if (!hasEndpoint && !hasSchema && !hasTargets) {
-            return {
-                success: false,
-                error: 'Config file must define "endpoint", "schema", or "targets".',
-            };
-        }
-        if (hasTargets) {
-            const targets = config.targets;
-            if (!targets || typeof targets !== 'object' || Array.isArray(targets)) {
-                return {
-                    success: false,
-                    error: 'Config file "targets" must be an object of named configs.',
-                };
-            }
-        }
         return {
             success: true,
             config,

package/core/config/resolver.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Configuration resolution utilities
+ *
+ * Functions for resolving and merging configuration from various sources
+ * (config file, CLI options, defaults) into a final resolved configuration.
+ */
+import type { GraphQLSDKConfigTarget } from '../../types/config';
+/**
+ * Options that can override config file settings.
+ * Extends GraphQLSDKConfigTarget with CLI-specific fields.
+ */
+export interface ConfigOverrideOptions extends GraphQLSDKConfigTarget {
+    /** Path to config file (CLI-only) */
+    config?: string;
+}
+/**
+ * Result of loading and resolving configuration
+ */
+export interface LoadConfigResult {
+    success: boolean;
+    config?: GraphQLSDKConfigTarget;
+    error?: string;
+}
+/**
+ * Load and resolve configuration from file and/or options
+ *
+ * This is the main entry point for configuration loading. It:
+ * 1. Finds and loads the config file (if any)
+ * 2. Applies CLI option overrides
+ * 3. Returns fully resolved configuration ready for use
+ */
+export declare function loadAndResolveConfig(options: ConfigOverrideOptions): Promise<LoadConfigResult>;
+/**
+ * Build watch configuration from options
+ *
+ * Used by watch mode to resolve configuration with watch-specific overrides.
+ */
+export declare function loadWatchConfig(options: {
+    config?: string;
+    endpoint?: string;
+    output?: string;
+    pollInterval?: number;
+    debounce?: number;
+    touch?: string;
+    clear?: boolean;
+}): Promise<GraphQLSDKConfigTarget | null>;

package/core/config/resolver.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAndResolveConfig = loadAndResolveConfig;
+exports.loadWatchConfig = loadWatchConfig;
+const config_1 = require("../../types/config");
+const loader_1 = require("./loader");
+/**
+ * Load and resolve configuration from file and/or options
+ *
+ * This is the main entry point for configuration loading. It:
+ * 1. Finds and loads the config file (if any)
+ * 2. Applies CLI option overrides
+ * 3. Returns fully resolved configuration ready for use
+ */
+async function loadAndResolveConfig(options) {
+    // Destructure CLI-only fields, rest is config overrides
+    const { config: configPath, ...overrides } = options;
+    // Validate that at most one source is specified
+    const sources = [
+        overrides.endpoint,
+        overrides.schemaFile,
+        overrides.db,
+    ].filter(Boolean);
+    if (sources.length > 1) {
+        return {
+            success: false,
+            error: 'Multiple sources specified. Use only one of: endpoint, schemaFile, or db.',
+        };
+    }
+    // Find config file
+    let resolvedConfigPath = configPath;
+    if (!resolvedConfigPath) {
+        resolvedConfigPath = (0, loader_1.findConfigFile)() ?? undefined;
+    }
+    let baseConfig = {};
+    if (resolvedConfigPath) {
+        const loadResult = await (0, loader_1.loadConfigFile)(resolvedConfigPath);
+        if (!loadResult.success) {
+            return { success: false, error: loadResult.error };
+        }
+        baseConfig = loadResult.config;
+    }
+    const mergedConfig = (0, config_1.mergeConfig)(baseConfig, overrides);
+    // Check if we have a source (endpoint, schemaFile, or db)
+    const hasSource = mergedConfig.endpoint ||
+        mergedConfig.schemaFile ||
+        mergedConfig.db;
+    if (!hasSource) {
+        return {
+            success: false,
+            error: 'No source specified. Use --endpoint, --schema-file, or --db, or create a config file with "graphql-codegen init".',
+        };
+    }
+    return {
+        success: true,
+        config: (0, config_1.getConfigOptions)(mergedConfig),
+    };
+}
+/**
+ * Build watch configuration from options
+ *
+ * Used by watch mode to resolve configuration with watch-specific overrides.
+ */
+async function loadWatchConfig(options) {
+    let configPath = options.config;
+    if (!configPath) {
+        configPath = (0, loader_1.findConfigFile)() ?? undefined;
+    }
+    let baseConfig = {};
+    if (configPath) {
+        const loadResult = await (0, loader_1.loadConfigFile)(configPath);
+        if (!loadResult.success) {
+            console.error('x', loadResult.error);
+            return null;
+        }
+        baseConfig = loadResult.config;
+    }
+    const sourceOverrides = {};
+    if (options.endpoint) {
+        sourceOverrides.endpoint = options.endpoint;
+        sourceOverrides.schemaFile = undefined;
+    }
+    const watchOverrides = {
+        watch: {
+            ...(options.pollInterval !== undefined && {
+                pollInterval: options.pollInterval,
+            }),
+            ...(options.debounce !== undefined && { debounce: options.debounce }),
+            ...(options.touch !== undefined && { touchFile: options.touch }),
+            ...(options.clear !== undefined && { clearScreen: options.clear }),
+        },
+    };
+    let mergedConfig = (0, config_1.mergeConfig)(baseConfig, sourceOverrides);
+    mergedConfig = (0, config_1.mergeConfig)(mergedConfig, watchOverrides);
+    if (!mergedConfig.endpoint) {
+        console.error('x No endpoint specified. Watch mode only supports live endpoints.');
+        return null;
+    }
+    if (mergedConfig.schemaFile) {
+        console.error('x Watch mode is only supported with an endpoint, not schemaFile.');
+        return null;
+    }
+    return (0, config_1.getConfigOptions)(mergedConfig);
+}

package/core/database/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Database schema utilities
+ *
+ * Provides functions for building GraphQL schemas directly from PostgreSQL databases.
+ */
+export interface BuildSchemaFromDatabaseOptions {
+    /** Database name */
+    database: string;
+    /** PostgreSQL schemas to include */
+    schemas: string[];
+    /** Output directory for the schema file */
+    outDir: string;
+    /** Optional filename (default: schema.graphql) */
+    filename?: string;
+}
+export interface BuildSchemaFromDatabaseResult {
+    /** Path to the generated schema file */
+    schemaPath: string;
+    /** The SDL content */
+    sdl: string;
+}
+/**
+ * Build a GraphQL schema from a PostgreSQL database and write it to a file.
+ *
+ * This function introspects the database using PostGraphile and generates
+ * a GraphQL SDL file that can be used for code generation.
+ *
+ * @param options - Configuration options
+ * @returns The path to the generated schema file and the SDL content
+ */
+export declare function buildSchemaFromDatabase(options: BuildSchemaFromDatabaseOptions): Promise<BuildSchemaFromDatabaseResult>;
+/**
+ * Build a GraphQL schema SDL string from a PostgreSQL database without writing to file.
+ *
+ * This is a convenience wrapper around buildSchemaSDL from graphql-server.
+ *
+ * @param options - Configuration options
+ * @returns The SDL content as a string
+ */
+export declare function buildSchemaSDLFromDatabase(options: {
+    database: string;
+    schemas: string[];
+}): Promise<string>;

package/core/database/index.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Database schema utilities
+ *
+ * Provides functions for building GraphQL schemas directly from PostgreSQL databases.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSchemaFromDatabase = buildSchemaFromDatabase;
+exports.buildSchemaSDLFromDatabase = buildSchemaSDLFromDatabase;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const graphql_server_1 = require("@constructive-io/graphql-server");
+/**
+ * Build a GraphQL schema from a PostgreSQL database and write it to a file.
+ *
+ * This function introspects the database using PostGraphile and generates
+ * a GraphQL SDL file that can be used for code generation.
+ *
+ * @param options - Configuration options
+ * @returns The path to the generated schema file and the SDL content
+ */
+async function buildSchemaFromDatabase(options) {
+    const { database, schemas, outDir, filename = 'schema.graphql' } = options;
+    // Ensure output directory exists
+    await fs.promises.mkdir(outDir, { recursive: true });
+    // Build schema SDL from database
+    const sdl = await (0, graphql_server_1.buildSchemaSDL)({
+        database,
+        schemas,
+        graphile: { pgSettings: async () => ({ role: 'administrator' }) },
+    });
+    // Write schema to file
+    const schemaPath = path.join(outDir, filename);
+    await fs.promises.writeFile(schemaPath, sdl, 'utf-8');
+    return { schemaPath, sdl };
+}
+/**
+ * Build a GraphQL schema SDL string from a PostgreSQL database without writing to file.
+ *
+ * This is a convenience wrapper around buildSchemaSDL from graphql-server.
+ *
+ * @param options - Configuration options
+ * @returns The SDL content as a string
+ */
+async function buildSchemaSDLFromDatabase(options) {
+    const { database, schemas } = options;
+    return (0, graphql_server_1.buildSchemaSDL)({
+        database,
+        schemas,
+        graphile: { pgSettings: async () => ({ role: 'administrator' }) },
+    });
+}

package/core/generate.d.ts

@@ -0,0 +1,22 @@
+import type { GraphQLSDKConfigTarget } from '../types/config';
+export interface GenerateOptions extends GraphQLSDKConfigTarget {
+    authorization?: string;
+    verbose?: boolean;
+    dryRun?: boolean;
+    skipCustomOperations?: boolean;
+}
+export interface GenerateResult {
+    success: boolean;
+    message: string;
+    output?: string;
+    tables?: string[];
+    filesWritten?: string[];
+    errors?: string[];
+}
+/**
+ * Main generate function - takes a single config and generates code
+ *
+ * This is the primary entry point for programmatic usage.
+ * For multiple configs, call this function in a loop.
+ */
+export declare function generate(options?: GenerateOptions): Promise<GenerateResult>;

package/core/generate.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = generate;
+/**
+ * Main generate function - orchestrates the entire codegen pipeline
+ *
+ * This is the primary entry point for programmatic usage.
+ * The CLI is a thin wrapper around this function.
+ */
+const path_1 = __importDefault(require("path"));
+const introspect_1 = require("./introspect");
+const pipeline_1 = require("./pipeline");
+const codegen_1 = require("./codegen");
+const orm_1 = require("./codegen/orm");
+const shared_1 = require("./codegen/shared");
+const output_1 = require("./output");
+const config_1 = require("../types/config");
+/**
+ * Main generate function - takes a single config and generates code
+ *
+ * This is the primary entry point for programmatic usage.
+ * For multiple configs, call this function in a loop.
+ */
+async function generate(options = {}) {
+    // Apply defaults to get resolved config
+    const config = (0, config_1.getConfigOptions)(options);
+    const outputRoot = config.output;
+    // Determine which generators to run
+    const runReactQuery = config.reactQuery ?? false;
+    const runOrm = config.orm ?? false;
+    if (!runReactQuery && !runOrm) {
+        return {
+            success: false,
+            message: 'No generators enabled. Use reactQuery: true or orm: true in your config.',
+            output: outputRoot,
+        };
+    }
+    // Validate source
+    const sourceValidation = (0, introspect_1.validateSourceOptions)({
+        endpoint: config.endpoint || undefined,
+        schemaFile: config.schemaFile || undefined,
+        db: config.db,
+    });
+    if (!sourceValidation.valid) {
+        return {
+            success: false,
+            message: sourceValidation.error,
+            output: outputRoot,
+        };
+    }
+    const source = (0, introspect_1.createSchemaSource)({
+        endpoint: config.endpoint || undefined,
+        schemaFile: config.schemaFile || undefined,
+        db: config.db,
+        authorization: options.authorization || config.headers?.['Authorization'],
+        headers: config.headers,
+    });
+    // Run pipeline
+    let pipelineResult;
+    try {
+        console.log(`Fetching schema from ${source.describe()}...`);
+        pipelineResult = await (0, pipeline_1.runCodegenPipeline)({
+            source,
+            config,
+            verbose: options.verbose,
+            skipCustomOperations: options.skipCustomOperations,
+        });
+    }
+    catch (err) {
+        return {
+            success: false,
+            message: `Failed to fetch schema: ${err instanceof Error ? err.message : 'Unknown error'}`,
+            output: outputRoot,
+        };
+    }
+    const { tables, customOperations } = pipelineResult;
+    // Validate tables
+    const tablesValidation = (0, pipeline_1.validateTablesFound)(tables);
+    if (!tablesValidation.valid) {
+        return {
+            success: false,
+            message: tablesValidation.error,
+            output: outputRoot,
+        };
+    }
+    const allFilesWritten = [];
+    const bothEnabled = runReactQuery && runOrm;
+    // Generate shared types when both are enabled
+    if (bothEnabled) {
+        console.log('Generating shared types...');
+        const sharedResult = (0, shared_1.generateSharedTypes)({
+            tables,
+            customOperations: {
+                queries: customOperations.queries,
+                mutations: customOperations.mutations,
+                typeRegistry: customOperations.typeRegistry,
+            },
+            config,
+        });
+        if (!options.dryRun) {
+            const writeResult = await (0, output_1.writeGeneratedFiles)(sharedResult.files, outputRoot, []);
+            if (!writeResult.success) {
+                return {
+                    success: false,
+                    message: `Failed to write shared types: ${writeResult.errors?.join(', ')}`,
+                    output: outputRoot,
+                    errors: writeResult.errors,
+                };
+            }
+            allFilesWritten.push(...(writeResult.filesWritten ?? []));
+        }
+    }
+    // Generate React Query hooks
+    if (runReactQuery) {
+        const hooksDir = path_1.default.join(outputRoot, 'hooks');
+        console.log('Generating React Query hooks...');
+        const { files } = (0, codegen_1.generate)({
+            tables,
+            customOperations: {
+                queries: customOperations.queries,
+                mutations: customOperations.mutations,
+                typeRegistry: customOperations.typeRegistry,
+            },
+            config,
+            sharedTypesPath: bothEnabled ? '..' : undefined,
+        });
+        if (!options.dryRun) {
+            const writeResult = await (0, output_1.writeGeneratedFiles)(files, hooksDir, ['queries', 'mutations']);
+            if (!writeResult.success) {
+                return {
+                    success: false,
+                    message: `Failed to write React Query hooks: ${writeResult.errors?.join(', ')}`,
+                    output: outputRoot,
+                    errors: writeResult.errors,
+                };
+            }
+            allFilesWritten.push(...(writeResult.filesWritten ?? []));
+        }
+    }
+    // Generate ORM client
+    if (runOrm) {
+        const ormDir = path_1.default.join(outputRoot, 'orm');
+        console.log('Generating ORM client...');
+        const { files } = (0, orm_1.generateOrm)({
+            tables,
+            customOperations: {
+                queries: customOperations.queries,
+                mutations: customOperations.mutations,
+                typeRegistry: customOperations.typeRegistry,
+            },
+            config,
+            sharedTypesPath: bothEnabled ? '..' : undefined,
+        });
+        if (!options.dryRun) {
+            const writeResult = await (0, output_1.writeGeneratedFiles)(files, ormDir, ['models', 'query', 'mutation']);
+            if (!writeResult.success) {
+                return {
+                    success: false,
+                    message: `Failed to write ORM client: ${writeResult.errors?.join(', ')}`,
+                    output: outputRoot,
+                    errors: writeResult.errors,
+                };
+            }
+            allFilesWritten.push(...(writeResult.filesWritten ?? []));
+        }
+    }
+    // Generate unified barrel when both are enabled
+    if (bothEnabled && !options.dryRun) {
+        const barrelContent = `/**
+ * Generated SDK - auto-generated, do not edit
+ * @generated by @constructive-io/graphql-codegen
+ */
+export * from './types';
+export * from './hooks';
+export * from './orm';
+`;
+        await (0, output_1.writeGeneratedFiles)([{ path: 'index.ts', content: barrelContent }], outputRoot, []);
+    }
+    const generators = [runReactQuery && 'React Query', runOrm && 'ORM'].filter(Boolean).join(' and ');
+    return {
+        success: true,
+        message: options.dryRun
+            ? `Dry run complete. Would generate ${generators} for ${tables.length} tables.`
+            : `Generated ${generators} for ${tables.length} tables. Files written to ${outputRoot}`,
+        output: outputRoot,
+        tables: tables.map((t) => t.name),
+        filesWritten: allFilesWritten,
+    };
+}

package/core/index.d.ts

@@ -1,8 +1,20 @@
 /**
- * Core query building exports
+ * Core module exports
+ *
+ * This module contains all the core business logic for graphql-codegen.
+ * The CLI is a thin wrapper around these core functions.
  */
+export { generate } from './generate';
+export type { GenerateOptions, GenerateResult } from './generate';
 export * from './types';
 export * from './ast';
 export * from './custom-ast';
 export { QueryBuilder, MetaObject } from './query-builder';
 export { validateMetaObject, convertFromMetaSchema } from './meta-object';
+export * from './config';
+export * from './codegen';
+export * from './introspect';
+export * from './pipeline';
+export * from './output';
+export * from './watch';
+export * from './database';

package/core/index.js

@@ -1,6 +1,9 @@
 "use strict";
 /**
- * Core query building exports
+ * Core module exports
+ *
+ * This module contains all the core business logic for graphql-codegen.
+ * The CLI is a thin wrapper around these core functions.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -17,7 +20,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertFromMetaSchema = exports.validateMetaObject = exports.MetaObject = exports.QueryBuilder = void 0;
+exports.convertFromMetaSchema = exports.validateMetaObject = exports.MetaObject = exports.QueryBuilder = exports.generate = void 0;
+// Main generate function (orchestrates the entire pipeline)
+var generate_1 = require("./generate");
+Object.defineProperty(exports, "generate", { enumerable: true, get: function () { return generate_1.generate; } });
 // Types
 __exportStar(require("./types"), exports);
 // AST generation
@@ -31,3 +37,17 @@ Object.defineProperty(exports, "MetaObject", { enumerable: true, get: function (
 var meta_object_1 = require("./meta-object");
 Object.defineProperty(exports, "validateMetaObject", { enumerable: true, get: function () { return meta_object_1.validateMetaObject; } });
 Object.defineProperty(exports, "convertFromMetaSchema", { enumerable: true, get: function () { return meta_object_1.convertFromMetaSchema; } });
+// Configuration loading and resolution
+__exportStar(require("./config"), exports);
+// Code generation
+__exportStar(require("./codegen"), exports);
+// Schema introspection
+__exportStar(require("./introspect"), exports);
+// Codegen pipeline
+__exportStar(require("./pipeline"), exports);
+// File output
+__exportStar(require("./output"), exports);
+// Watch mode
+__exportStar(require("./watch"), exports);
+// Database schema utilities
+__exportStar(require("./database"), exports);