noormme 1.0.0

package/dist/cjs/schema/dialects/sqlite/introspection/sqlite-schema-introspector.d.ts

@@ -0,0 +1,31 @@
+import type { Kysely } from '../../../../kysely.js';
+import { DatabaseIntrospector } from '../../../../dialect/database-introspector.js';
+/**
+ * SQLite-specific schema introspector with enhanced metadata capabilities
+ */
+export declare class SQLiteSchemaIntrospector extends DatabaseIntrospector {
+    constructor(db: Kysely<any>);
+    /**
+     * Get enhanced table metadata for SQLite
+     */
+    getEnhancedTables(): Promise<any[]>;
+    /**
+     * Get database statistics for SQLite using PRAGMA
+     */
+    getDatabaseStats(): Promise<any>;
+    /**
+     * Get SQLite-specific information
+     */
+    getSQLiteInfo(): Promise<any>;
+    /**
+     * Get SQLite database integrity check results
+     */
+    checkIntegrity(): Promise<{
+        isValid: boolean;
+        issues: string[];
+    }>;
+    /**
+     * Get SQLite database optimization recommendations
+     */
+    getOptimizationRecommendations(): Promise<string[]>;
+}

package/dist/cjs/schema/dialects/sqlite/introspection/sqlite-schema-introspector.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteSchemaIntrospector = void 0;
+const database_introspector_js_1 = require("../../../../dialect/database-introspector.js");
+const sql_js_1 = require("../../../../raw-builder/sql.js");
+/**
+ * SQLite-specific schema introspector with enhanced metadata capabilities
+ */
+class SQLiteSchemaIntrospector extends database_introspector_js_1.DatabaseIntrospector {
+    constructor(db) {
+        super(db);
+    }
+    /**
+     * Get enhanced table metadata for SQLite
+     */
+    async getEnhancedTables() {
+        try {
+            const tables = await this.db
+                .selectFrom('sqlite_master')
+                .select([
+                'name',
+                'type',
+                'tbl_name',
+                'rootpage',
+                'sql'
+            ])
+                .where('type', '=', 'table')
+                .execute();
+            const enhancedTables = [];
+            for (const table of tables) {
+                try {
+                    // Get row count for each table
+                    const rowCountResult = await (0, sql_js_1.sql) `SELECT COUNT(*) as count FROM ${sql_js_1.sql.id(table.name)}`.execute(this.db);
+                    const rowCount = rowCountResult.rows?.[0]?.count || 0;
+                    enhancedTables.push({
+                        ...table,
+                        estimatedRows: rowCount,
+                        sizeBytes: 0, // SQLite doesn't provide direct size info
+                        comment: null, // SQLite doesn't support table comments
+                        hasIndexes: false, // Will be determined separately
+                        hasTriggers: false, // Will be determined separately
+                        tableType: 'table',
+                        lastAnalyzed: null,
+                        lastAutoAnalyzed: null
+                    });
+                }
+                catch (error) {
+                    console.warn(`Failed to get row count for SQLite table ${table.name}:`, error);
+                    enhancedTables.push(table);
+                }
+            }
+            return enhancedTables;
+        }
+        catch (error) {
+            console.warn('Failed to get enhanced SQLite table metadata:', error);
+            return [];
+        }
+    }
+    /**
+     * Get database statistics for SQLite using PRAGMA
+     */
+    async getDatabaseStats() {
+        try {
+            const stats = {};
+            // Get various PRAGMA values
+            const pragmas = [
+                'user_version',
+                'application_id',
+                'page_count',
+                'page_size',
+                'cache_size',
+                'freelist_count',
+                'synchronous',
+                'journal_mode',
+                'auto_vacuum',
+                'integrity_check'
+            ];
+            for (const pragma of pragmas) {
+                try {
+                    const result = await (0, sql_js_1.sql) `PRAGMA ${sql_js_1.sql.id(pragma)}`.execute(this.db);
+                    stats[pragma] = result.rows?.[0]?.[pragma] || null;
+                }
+                catch (error) {
+                    stats[pragma] = null;
+                }
+            }
+            return {
+                databaseName: 'main',
+                activeConnections: 1, // SQLite is single-connection
+                committedTransactions: stats.user_version || 0,
+                rolledBackTransactions: 0,
+                blocksRead: stats.page_count || 0,
+                blocksHit: stats.cache_size || 0,
+                tuplesReturned: 0,
+                tuplesFetched: 0,
+                tuplesInserted: 0,
+                tuplesUpdated: 0,
+                tuplesDeleted: 0,
+                statsReset: null,
+                pageSize: stats.page_size,
+                journalMode: stats.journal_mode,
+                autoVacuum: stats.auto_vacuum,
+                synchronous: stats.synchronous
+            };
+        }
+        catch (error) {
+            console.warn('Failed to get SQLite database stats:', error);
+            return null;
+        }
+    }
+    /**
+     * Get SQLite-specific information
+     */
+    async getSQLiteInfo() {
+        try {
+            const info = {};
+            // Get SQLite version
+            const versionResult = await (0, sql_js_1.sql) `SELECT sqlite_version() as version`.execute(this.db);
+            info.version = versionResult.rows?.[0]?.version;
+            // Get compile options
+            const compileOptionsResult = await (0, sql_js_1.sql) `PRAGMA compile_options`.execute(this.db);
+            info.compileOptions = compileOptionsResult.rows?.map((row) => row.compile_options) || [];
+            // Get foreign key status
+            const fkResult = await (0, sql_js_1.sql) `PRAGMA foreign_keys`.execute(this.db);
+            info.foreignKeysEnabled = fkResult.rows?.[0]?.foreign_keys === 1;
+            return info;
+        }
+        catch (error) {
+            console.warn('Failed to get SQLite info:', error);
+            return {};
+        }
+    }
+    /**
+     * Get SQLite database integrity check results
+     */
+    async checkIntegrity() {
+        try {
+            const result = await (0, sql_js_1.sql) `PRAGMA integrity_check`.execute(this.db);
+            const issues = [];
+            let isValid = true;
+            for (const row of result.rows || []) {
+                const check = row.integrity_check;
+                if (check !== 'ok') {
+                    issues.push(check);
+                    isValid = false;
+                }
+            }
+            return { isValid, issues };
+        }
+        catch (error) {
+            console.warn('Failed to check SQLite integrity:', error);
+            return { isValid: false, issues: ['Integrity check failed'] };
+        }
+    }
+    /**
+     * Get SQLite database optimization recommendations
+     */
+    async getOptimizationRecommendations() {
+        const recommendations = [];
+        try {
+            // Check for unused pages
+            const freelistResult = await (0, sql_js_1.sql) `PRAGMA freelist_count`.execute(this.db);
+            const freelistCount = freelistResult.rows?.[0]?.freelist_count || 0;
+            if (freelistCount > 0) {
+                recommendations.push(`Consider running VACUUM to reclaim ${freelistCount} unused pages`);
+            }
+            // Check page size
+            const pageSizeResult = await (0, sql_js_1.sql) `PRAGMA page_size`.execute(this.db);
+            const pageSize = pageSizeResult.rows?.[0]?.page_size || 0;
+            if (pageSize < 4096) {
+                recommendations.push('Consider using a larger page size (4096 or 8192) for better performance');
+            }
+            // Check journal mode
+            const journalModeResult = await (0, sql_js_1.sql) `PRAGMA journal_mode`.execute(this.db);
+            const journalMode = journalModeResult.rows?.[0]?.journal_mode;
+            if (journalMode !== 'WAL') {
+                recommendations.push('Consider using WAL mode for better concurrency: PRAGMA journal_mode = WAL');
+            }
+            // Check cache size
+            const cacheSizeResult = await (0, sql_js_1.sql) `PRAGMA cache_size`.execute(this.db);
+            const cacheSize = cacheSizeResult.rows?.[0]?.cache_size || 0;
+            if (cacheSize < -1000) {
+                recommendations.push('Consider increasing cache size for better performance');
+            }
+        }
+        catch (error) {
+            console.warn('Failed to get SQLite optimization recommendations:', error);
+        }
+        return recommendations;
+    }
+}
+exports.SQLiteSchemaIntrospector = SQLiteSchemaIntrospector;

package/dist/cjs/schema/dialects/sqlite/sqlite-discovery.coordinator.d.ts

@@ -0,0 +1,51 @@
+import type { Kysely } from '../../../kysely.js';
+import { SchemaInfo, IntrospectionConfig } from '../../../types/index.js';
+/**
+ * SQLite-specific schema discovery coordinator
+ */
+export declare class SQLiteDiscoveryCoordinator {
+    private static instance;
+    private tableDiscovery;
+    private relationshipDiscovery;
+    private viewDiscovery;
+    private indexDiscovery;
+    private constraintDiscovery;
+    private constructor();
+    static getInstance(): SQLiteDiscoveryCoordinator;
+    /**
+     * Discover complete SQLite schema
+     */
+    discoverSchema(db: Kysely<any>, config?: IntrospectionConfig): Promise<SchemaInfo>;
+    /**
+     * Enhance table metadata with SQLite-specific information
+     */
+    private enhanceTablesWithSQLiteMetadata;
+    /**
+     * Get SQLite-specific capabilities
+     */
+    getCapabilities(): {
+        supportsViews: boolean;
+        supportsIndexes: boolean;
+        supportsConstraints: boolean;
+        supportsForeignKeys: boolean;
+        supportsCheckConstraints: boolean;
+        supportsDeferredConstraints: boolean;
+        supportsPartialIndexes: boolean;
+        supportsExpressionIndexes: boolean;
+        supportsConcurrentIndexCreation: boolean;
+        supportsMaterializedViews: boolean;
+        supportsCustomTypes: boolean;
+        supportsExtensions: boolean;
+        supportsPRAGMA: boolean;
+        supportsAutoIncrement: boolean;
+        supportsRowId: boolean;
+    };
+    /**
+     * Get SQLite-specific recommendations
+     */
+    getRecommendations(db: Kysely<any>, tables: any[]): Promise<string[]>;
+    /**
+     * Get SQLite configuration recommendations
+     */
+    getConfigurationRecommendations(): string[];
+}

package/dist/cjs/schema/dialects/sqlite/sqlite-discovery.coordinator.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteDiscoveryCoordinator = void 0;
+const database_introspector_js_1 = require("../../../dialect/database-introspector.js");
+const table_metadata_discovery_js_1 = require("../../core/discovery/table-metadata-discovery.js");
+const relationship_discovery_js_1 = require("../../core/discovery/relationship-discovery.js");
+const view_discovery_js_1 = require("../../core/discovery/view-discovery.js");
+const sqlite_index_discovery_js_1 = require("./discovery/sqlite-index-discovery.js");
+const sqlite_constraint_discovery_js_1 = require("./discovery/sqlite-constraint-discovery.js");
+/**
+ * SQLite-specific schema discovery coordinator
+ */
+class SQLiteDiscoveryCoordinator {
+    static instance;
+    tableDiscovery;
+    relationshipDiscovery;
+    viewDiscovery;
+    indexDiscovery;
+    constraintDiscovery;
+    constructor() {
+        this.tableDiscovery = table_metadata_discovery_js_1.TableMetadataDiscovery.getInstance();
+        this.relationshipDiscovery = relationship_discovery_js_1.RelationshipDiscovery.getInstance();
+        this.viewDiscovery = view_discovery_js_1.ViewDiscovery.getInstance();
+        this.indexDiscovery = sqlite_index_discovery_js_1.SQLiteIndexDiscovery.getInstance();
+        this.constraintDiscovery = sqlite_constraint_discovery_js_1.SQLiteConstraintDiscovery.getInstance();
+    }
+    static getInstance() {
+        if (!SQLiteDiscoveryCoordinator.instance) {
+            SQLiteDiscoveryCoordinator.instance = new SQLiteDiscoveryCoordinator();
+        }
+        return SQLiteDiscoveryCoordinator.instance;
+    }
+    /**
+     * Discover complete SQLite schema
+     */
+    async discoverSchema(db, config = {}) {
+        const introspector = new database_introspector_js_1.DatabaseIntrospector(db);
+        const discoveryConfig = {
+            excludeTables: config.excludeTables,
+            includeViews: config.includeViews,
+            customTypeMappings: config.customTypeMappings
+        };
+        // Check if foreign keys are enabled
+        const fkEnabled = await this.constraintDiscovery.isForeignKeySupportEnabled(db);
+        // Discover tables with SQLite-specific metadata
+        const tables = await this.tableDiscovery.discoverTables(introspector, discoveryConfig);
+        // Enhance tables with SQLite-specific index and constraint information
+        const enhancedTables = await this.enhanceTablesWithSQLiteMetadata(db, tables, fkEnabled);
+        // Discover relationships (only if foreign keys are enabled)
+        const relationships = fkEnabled
+            ? await this.relationshipDiscovery.discoverRelationships(enhancedTables)
+            : [];
+        // Discover views if requested
+        const viewMetadata = discoveryConfig.includeViews
+            ? await this.viewDiscovery.discoverViews(introspector)
+            : [];
+        const views = viewMetadata.map(view => ({
+            name: view.name,
+            schema: view.schema,
+            definition: view.definition || '',
+            columns: view.columns || []
+        }));
+        return {
+            tables: enhancedTables,
+            relationships,
+            views
+        };
+    }
+    /**
+     * Enhance table metadata with SQLite-specific information
+     */
+    async enhanceTablesWithSQLiteMetadata(db, tables, fkEnabled) {
+        const enhancedTables = [];
+        for (const table of tables) {
+            try {
+                // Get SQLite-specific index information
+                const indexes = await this.indexDiscovery.discoverTableIndexes(db, table.name);
+                // Get SQLite-specific constraint information from table definition
+                const constraints = await this.constraintDiscovery.discoverTableConstraints(db, table.name);
+                // Get foreign key information using PRAGMA (if enabled)
+                const foreignKeys = fkEnabled
+                    ? await this.constraintDiscovery.getForeignKeyInfo(db, table.name)
+                    : [];
+                // Get table size information
+                const tableSize = await this.indexDiscovery.getTableSize(db, table.name);
+                enhancedTables.push({
+                    ...table,
+                    indexes: indexes.map(idx => ({
+                        name: idx.name,
+                        columns: idx.columns,
+                        unique: idx.unique,
+                        isPrimary: idx.isPrimary,
+                        definition: idx.definition
+                    })),
+                    constraints: constraints,
+                    foreignKeys: foreignKeys.map(fk => ({
+                        name: fk.name,
+                        column: fk.column,
+                        referencedTable: fk.referencedTable,
+                        referencedColumn: fk.referencedColumn,
+                        onDelete: fk.onDelete,
+                        onUpdate: fk.onUpdate
+                    })),
+                    tableSize: tableSize
+                });
+            }
+            catch (error) {
+                console.warn(`Failed to enhance SQLite metadata for table ${table.name}:`, error);
+                enhancedTables.push(table);
+            }
+        }
+        return enhancedTables;
+    }
+    /**
+     * Get SQLite-specific capabilities
+     */
+    getCapabilities() {
+        return {
+            supportsViews: true,
+            supportsIndexes: true,
+            supportsConstraints: true,
+            supportsForeignKeys: false, // Depends on PRAGMA foreign_keys setting
+            supportsCheckConstraints: true,
+            supportsDeferredConstraints: false,
+            supportsPartialIndexes: true,
+            supportsExpressionIndexes: true,
+            supportsConcurrentIndexCreation: false,
+            supportsMaterializedViews: false,
+            supportsCustomTypes: false,
+            supportsExtensions: false,
+            supportsPRAGMA: true,
+            supportsAutoIncrement: true,
+            supportsRowId: true
+        };
+    }
+    /**
+     * Get SQLite-specific recommendations
+     */
+    async getRecommendations(db, tables) {
+        const recommendations = [];
+        // Check foreign key support
+        const fkEnabled = await this.constraintDiscovery.isForeignKeySupportEnabled(db);
+        if (!fkEnabled) {
+            recommendations.push('Consider enabling foreign key support with PRAGMA foreign_keys = ON for better data integrity');
+        }
+        for (const table of tables) {
+            try {
+                // Analyze indexes
+                const indexes = await this.indexDiscovery.discoverTableIndexes(db, table.name);
+                const indexAnalysis = this.indexDiscovery.analyzeIndexEfficiency(indexes);
+                recommendations.push(...indexAnalysis.recommendations);
+                // Analyze constraints for compatibility
+                const constraints = await this.constraintDiscovery.discoverTableConstraints(db, table.name);
+                const constraintAnalysis = this.constraintDiscovery.analyzeConstraintCompatibility(constraints);
+                recommendations.push(...constraintAnalysis.recommendations);
+                // Check for table without primary key
+                if (!table.primaryKey || table.primaryKey.length === 0) {
+                    recommendations.push(`Table ${table.name} should have a primary key for better performance`);
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to get recommendations for SQLite table ${table.name}:`, error);
+            }
+        }
+        return recommendations;
+    }
+    /**
+     * Get SQLite configuration recommendations
+     */
+    getConfigurationRecommendations() {
+        return [
+            'Enable foreign key constraints: PRAGMA foreign_keys = ON',
+            'Use WAL mode for better concurrency: PRAGMA journal_mode = WAL',
+            'Set appropriate cache size: PRAGMA cache_size = -64000',
+            'Enable query optimization: PRAGMA optimize',
+            'Consider using prepared statements for better performance'
+        ];
+    }
+}
+exports.SQLiteDiscoveryCoordinator = SQLiteDiscoveryCoordinator;

package/dist/cjs/schema/index.d.ts

@@ -0,0 +1,14 @@
+export { SchemaDiscovery } from './schema-discovery.js';
+export { SchemaDiscoveryCoordinator } from './core/coordinators/schema-discovery.coordinator.js';
+export { DiscoveryFactory } from './core/factories/discovery-factory.js';
+export { TableMetadataDiscovery } from './core/discovery/table-metadata-discovery.js';
+export { RelationshipDiscovery } from './core/discovery/relationship-discovery.js';
+export { ViewDiscovery } from './core/discovery/view-discovery.js';
+export { TypeMapper } from './core/utils/type-mapper.js';
+export { NameGenerator } from './core/utils/name-generator.js';
+export * from './core/types/schema-discovery-types.js';
+export { SQLiteDiscoveryCoordinator } from './dialects/sqlite/sqlite-discovery.coordinator.js';
+export { SQLiteIndexDiscovery } from './dialects/sqlite/discovery/sqlite-index-discovery.js';
+export { SQLiteConstraintDiscovery } from './dialects/sqlite/discovery/sqlite-constraint-discovery.js';
+export { SQLiteSchemaIntrospector } from './dialects/sqlite/introspection/sqlite-schema-introspector.js';
+export * from './builders/index.js';

package/dist/cjs/schema/index.js

@@ -0,0 +1,49 @@
+"use strict";
+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 __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.SQLiteSchemaIntrospector = exports.SQLiteConstraintDiscovery = exports.SQLiteIndexDiscovery = exports.SQLiteDiscoveryCoordinator = exports.NameGenerator = exports.TypeMapper = exports.ViewDiscovery = exports.RelationshipDiscovery = exports.TableMetadataDiscovery = exports.DiscoveryFactory = exports.SchemaDiscoveryCoordinator = exports.SchemaDiscovery = void 0;
+// Main schema discovery class
+var schema_discovery_js_1 = require("./schema-discovery.js");
+Object.defineProperty(exports, "SchemaDiscovery", { enumerable: true, get: function () { return schema_discovery_js_1.SchemaDiscovery; } });
+// Core Components
+var schema_discovery_coordinator_js_1 = require("./core/coordinators/schema-discovery.coordinator.js");
+Object.defineProperty(exports, "SchemaDiscoveryCoordinator", { enumerable: true, get: function () { return schema_discovery_coordinator_js_1.SchemaDiscoveryCoordinator; } });
+var discovery_factory_js_1 = require("./core/factories/discovery-factory.js");
+Object.defineProperty(exports, "DiscoveryFactory", { enumerable: true, get: function () { return discovery_factory_js_1.DiscoveryFactory; } });
+// Core Discovery Services
+var table_metadata_discovery_js_1 = require("./core/discovery/table-metadata-discovery.js");
+Object.defineProperty(exports, "TableMetadataDiscovery", { enumerable: true, get: function () { return table_metadata_discovery_js_1.TableMetadataDiscovery; } });
+var relationship_discovery_js_1 = require("./core/discovery/relationship-discovery.js");
+Object.defineProperty(exports, "RelationshipDiscovery", { enumerable: true, get: function () { return relationship_discovery_js_1.RelationshipDiscovery; } });
+var view_discovery_js_1 = require("./core/discovery/view-discovery.js");
+Object.defineProperty(exports, "ViewDiscovery", { enumerable: true, get: function () { return view_discovery_js_1.ViewDiscovery; } });
+// Core Utilities and Types
+var type_mapper_js_1 = require("./core/utils/type-mapper.js");
+Object.defineProperty(exports, "TypeMapper", { enumerable: true, get: function () { return type_mapper_js_1.TypeMapper; } });
+var name_generator_js_1 = require("./core/utils/name-generator.js");
+Object.defineProperty(exports, "NameGenerator", { enumerable: true, get: function () { return name_generator_js_1.NameGenerator; } });
+__exportStar(require("./core/types/schema-discovery-types.js"), exports);
+// SQLite Dialect
+var sqlite_discovery_coordinator_js_1 = require("./dialects/sqlite/sqlite-discovery.coordinator.js");
+Object.defineProperty(exports, "SQLiteDiscoveryCoordinator", { enumerable: true, get: function () { return sqlite_discovery_coordinator_js_1.SQLiteDiscoveryCoordinator; } });
+var sqlite_index_discovery_js_1 = require("./dialects/sqlite/discovery/sqlite-index-discovery.js");
+Object.defineProperty(exports, "SQLiteIndexDiscovery", { enumerable: true, get: function () { return sqlite_index_discovery_js_1.SQLiteIndexDiscovery; } });
+var sqlite_constraint_discovery_js_1 = require("./dialects/sqlite/discovery/sqlite-constraint-discovery.js");
+Object.defineProperty(exports, "SQLiteConstraintDiscovery", { enumerable: true, get: function () { return sqlite_constraint_discovery_js_1.SQLiteConstraintDiscovery; } });
+var sqlite_schema_introspector_js_1 = require("./dialects/sqlite/introspection/sqlite-schema-introspector.js");
+Object.defineProperty(exports, "SQLiteSchemaIntrospector", { enumerable: true, get: function () { return sqlite_schema_introspector_js_1.SQLiteSchemaIntrospector; } });
+// Schema Builders
+__exportStar(require("./builders/index.js"), exports);

package/dist/cjs/schema/schema-discovery.d.ts

@@ -0,0 +1,23 @@
+import type { Kysely } from '../kysely.js';
+import { SchemaInfo, IntrospectionConfig } from '../types';
+import type { Dialect } from '../dialect/dialect.js';
+import { SchemaDiscoveryCoordinator } from './core/coordinators/schema-discovery.coordinator.js';
+/**
+ * Schema discovery engine that introspects database structure
+ * This is now a thin wrapper around the SchemaDiscoveryCoordinator
+ */
+export declare class SchemaDiscovery {
+    private db;
+    private config;
+    private dialect?;
+    private coordinator;
+    constructor(db: Kysely<any>, config?: IntrospectionConfig, dialect?: Dialect | undefined);
+    /**
+     * Discover the complete database schema
+     */
+    discoverSchema(): Promise<SchemaInfo>;
+    /**
+     * Get the coordinator instance for advanced operations
+     */
+    getCoordinator(): SchemaDiscoveryCoordinator;
+}

package/dist/cjs/schema/schema-discovery.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaDiscovery = void 0;
+const schema_discovery_coordinator_js_1 = require("./core/coordinators/schema-discovery.coordinator.js");
+/**
+ * Schema discovery engine that introspects database structure
+ * This is now a thin wrapper around the SchemaDiscoveryCoordinator
+ */
+class SchemaDiscovery {
+    db;
+    config;
+    dialect;
+    coordinator;
+    constructor(db, config = {}, dialect) {
+        this.db = db;
+        this.config = config;
+        this.dialect = dialect;
+        this.coordinator = schema_discovery_coordinator_js_1.SchemaDiscoveryCoordinator.getInstance();
+    }
+    /**
+     * Discover the complete database schema
+     */
+    async discoverSchema() {
+        return await this.coordinator.discoverSchema(this.db, this.config, this.dialect);
+    }
+    /**
+     * Get the coordinator instance for advanced operations
+     */
+    getCoordinator() {
+        return this.coordinator;
+    }
+}
+exports.SchemaDiscovery = SchemaDiscovery;