noormme 1.0.0

package/dist/esm/schema/test/basic-schema-test.js

@@ -0,0 +1,183 @@
+/// <reference types="./basic-schema-test.d.ts" />
+/**
+ * Basic Schema Strategy Test
+ *
+ * This is a simple test to verify the schema strategy components work correctly
+ * without complex Jest mocking dependencies.
+ */
+// Simple test framework
+class SimpleTest {
+    tests = [];
+    passed = 0;
+    failed = 0;
+    test(name, fn) {
+        this.tests.push({ name, fn });
+    }
+    expect(value) {
+        return {
+            toBe: (expected) => {
+                if (value === expected) {
+                    this.passed++;
+                    console.log(`✅ ${value} === ${expected}`);
+                }
+                else {
+                    this.failed++;
+                    console.log(`❌ Expected ${expected}, got ${value}`);
+                }
+            },
+            toBeDefined: () => {
+                if (value !== undefined) {
+                    this.passed++;
+                    console.log(`✅ ${value} is defined`);
+                }
+                else {
+                    this.failed++;
+                    console.log(`❌ Expected defined value, got undefined`);
+                }
+            },
+            toThrow: (expectedError) => {
+                try {
+                    if (typeof value === 'function') {
+                        value();
+                    }
+                    this.failed++;
+                    console.log(`❌ Expected function to throw, but it didn't`);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    if (!expectedError || errorMessage.includes(expectedError)) {
+                        this.passed++;
+                        console.log(`✅ Function threw as expected: ${errorMessage}`);
+                    }
+                    else {
+                        this.failed++;
+                        console.log(`❌ Expected error containing "${expectedError}", got: ${errorMessage}`);
+                    }
+                }
+            }
+        };
+    }
+    async run() {
+        console.log('🧪 Running Basic Schema Strategy Tests...\n');
+        for (const test of this.tests) {
+            console.log(`\n📋 ${test.name}`);
+            try {
+                test.fn();
+            }
+            catch (error) {
+                this.failed++;
+                console.log(`❌ Test failed with error: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        console.log(`\n📊 Test Results:`);
+        console.log(`✅ Passed: ${this.passed}`);
+        console.log(`❌ Failed: ${this.failed}`);
+        console.log(`📈 Total: ${this.tests.length}`);
+        if (this.failed === 0) {
+            console.log('\n🎉 All tests passed!');
+        }
+        else {
+            console.log('\n💥 Some tests failed!');
+            process.exit(1);
+        }
+    }
+}
+// Import the components we want to test
+async function runTests() {
+    const test = new SimpleTest();
+    // Test 1: DiscoveryFactory Singleton
+    test.test('DiscoveryFactory should be a singleton', () => {
+        try {
+            const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+            const instance1 = DiscoveryFactory.getInstance();
+            const instance2 = DiscoveryFactory.getInstance();
+            test.expect(instance1).toBe(instance2);
+        }
+        catch (error) {
+            console.log('⚠️  DiscoveryFactory test skipped (module not available)');
+        }
+    });
+    // Test 2: SchemaDiscoveryCoordinator Singleton
+    test.test('SchemaDiscoveryCoordinator should be a singleton', () => {
+        try {
+            const { SchemaDiscoveryCoordinator } = require('../core/coordinators/schema-discovery.coordinator.js');
+            const instance1 = SchemaDiscoveryCoordinator.getInstance();
+            const instance2 = SchemaDiscoveryCoordinator.getInstance();
+            test.expect(instance1).toBe(instance2);
+        }
+        catch (error) {
+            console.log('⚠️  SchemaDiscoveryCoordinator test skipped (module not available)');
+        }
+    });
+    // Test 4: SQLite Coordinator Singleton
+    test.test('SQLiteDiscoveryCoordinator should be a singleton', () => {
+        try {
+            const { SQLiteDiscoveryCoordinator } = require('../dialects/sqlite/sqlite-discovery.coordinator.js');
+            const instance1 = SQLiteDiscoveryCoordinator.getInstance();
+            const instance2 = SQLiteDiscoveryCoordinator.getInstance();
+            test.expect(instance1).toBe(instance2);
+        }
+        catch (error) {
+            console.log('⚠️  SQLiteDiscoveryCoordinator test skipped (module not available)');
+        }
+    });
+    // Test 5: Factory Dialect Support
+    test.test('DiscoveryFactory should support PostgreSQL and SQLite', () => {
+        try {
+            const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+            const factory = DiscoveryFactory.getInstance();
+            test.expect(factory.isDialectSupported('postgresql')).toBe(true);
+            test.expect(factory.isDialectSupported('sqlite')).toBe(true);
+            test.expect(factory.isDialectSupported('mysql')).toBe(false);
+        }
+        catch (error) {
+            console.log('⚠️  Factory dialect support test skipped (module not available)');
+        }
+    });
+    // Test 6: Error Handling
+    test.test('DiscoveryFactory should throw error for unsupported dialects', () => {
+        try {
+            const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+            const factory = DiscoveryFactory.getInstance();
+            test.expect(() => factory.createIndexDiscovery('oracle')).toThrow('Unsupported dialect');
+        }
+        catch (error) {
+            console.log('⚠️  Error handling test skipped (module not available)');
+        }
+    });
+    // Test 7: Capabilities
+    test.test('PostgreSQL should have correct capabilities', () => {
+        try {
+            const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+            const factory = DiscoveryFactory.getInstance();
+            const capabilities = factory.getDialectCapabilities('postgresql');
+            test.expect(capabilities.supportsViews).toBe(true);
+            test.expect(capabilities.supportsIndexes).toBe(true);
+            test.expect(capabilities.supportsConstraints).toBe(true);
+        }
+        catch (error) {
+            console.log('⚠️  PostgreSQL capabilities test skipped (module not available)');
+        }
+    });
+    // Test 8: SQLite Capabilities
+    test.test('SQLite should have correct capabilities', () => {
+        try {
+            const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+            const factory = DiscoveryFactory.getInstance();
+            const capabilities = factory.getDialectCapabilities('sqlite');
+            test.expect(capabilities.supportsViews).toBe(true);
+            test.expect(capabilities.supportsIndexes).toBe(true);
+            test.expect(capabilities.supportsConstraints).toBe(true);
+            test.expect(capabilities.supportsDeferredConstraints).toBe(false);
+        }
+        catch (error) {
+            console.log('⚠️  SQLite capabilities test skipped (module not available)');
+        }
+    });
+    await test.run();
+}
+// Run the tests
+if (require.main === module) {
+    runTests().catch(console.error);
+}
+export { runTests };

package/dist/esm/schema/test/dialect-capabilities.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/schema/test/dialect-capabilities.test.js

@@ -0,0 +1,152 @@
+/// <reference types="./dialect-capabilities.test.d.ts" />
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { DiscoveryFactory } from '../core/factories/discovery-factory.js';
+import { SQLiteDiscoveryCoordinator } from '../dialects/sqlite/sqlite-discovery.coordinator.js';
+describe('Dialect Capabilities', () => {
+    let factory;
+    let sqliteCoordinator;
+    beforeEach(() => {
+        // Reset singleton instances
+        ;
+        DiscoveryFactory.instance = undefined;
+        SQLiteDiscoveryCoordinator.instance = undefined;
+        factory = DiscoveryFactory.getInstance();
+        sqliteCoordinator = SQLiteDiscoveryCoordinator.getInstance();
+    });
+    describe('Factory Capability Detection', () => {
+        describe('SQLite Capabilities', () => {
+            it('should return correct capabilities for sqlite', () => {
+                const capabilities = factory.getDialectCapabilities('sqlite');
+                expect(capabilities).toEqual({
+                    supportsViews: true,
+                    supportsIndexes: true,
+                    supportsConstraints: true,
+                    supportsForeignKeys: true,
+                    supportsCheckConstraints: true,
+                    supportsDeferredConstraints: false
+                });
+            });
+            it('should handle case insensitive dialect names', () => {
+                const capabilities = factory.getDialectCapabilities('SQLITE');
+                expect(capabilities).toEqual({
+                    supportsViews: true,
+                    supportsIndexes: true,
+                    supportsConstraints: true,
+                    supportsForeignKeys: true,
+                    supportsCheckConstraints: true,
+                    supportsDeferredConstraints: false
+                });
+            });
+        });
+        it('should return false capabilities for unsupported dialects', () => {
+            const capabilities = factory.getDialectCapabilities('unsupported');
+            expect(capabilities).toEqual({
+                supportsViews: false,
+                supportsIndexes: false,
+                supportsConstraints: false,
+                supportsForeignKeys: false,
+                supportsCheckConstraints: false,
+                supportsDeferredConstraints: false
+            });
+        });
+        it('should handle dialect name with whitespace', () => {
+            const capabilities = factory.getDialectCapabilities(' sqlite ');
+            expect(capabilities).toEqual({
+                supportsViews: true,
+                supportsIndexes: true,
+                supportsConstraints: true,
+                supportsForeignKeys: true,
+                supportsCheckConstraints: true,
+                supportsDeferredConstraints: false
+            });
+        });
+        it('should handle mixed case dialect names', () => {
+            const capabilities = factory.getDialectCapabilities('Sqlite');
+            expect(capabilities).toEqual({
+                supportsViews: true,
+                supportsIndexes: true,
+                supportsConstraints: true,
+                supportsForeignKeys: true,
+                supportsCheckConstraints: true,
+                supportsDeferredConstraints: false
+            });
+        });
+    });
+    describe('Coordinator-Specific Capabilities', () => {
+        describe('SQLite Coordinator Capabilities', () => {
+            it('should return extended SQLite capabilities', () => {
+                const capabilities = sqliteCoordinator.getCapabilities();
+                expect(capabilities).toEqual({
+                    supportsViews: true,
+                    supportsIndexes: true,
+                    supportsConstraints: true,
+                    supportsForeignKeys: true,
+                    supportsCheckConstraints: true,
+                    supportsDeferredConstraints: false,
+                    supportsPartialIndexes: true,
+                    supportsExpressionIndexes: true,
+                    supportsMaterializedViews: false,
+                    supportsTriggers: true,
+                    supportsFullTextSearch: true
+                });
+            });
+            it('should support all SQLite features', () => {
+                const capabilities = sqliteCoordinator.getCapabilities();
+                expect(capabilities.supportsPartialIndexes).toBe(true);
+                expect(capabilities.supportsExpressionIndexes).toBe(true);
+                expect(capabilities.supportsMaterializedViews).toBe(false);
+            });
+        });
+    });
+    describe('Capability Consistency', () => {
+        it('should have consistent capabilities between factory and coordinator for SQLite', () => {
+            const factoryCapabilities = factory.getDialectCapabilities('sqlite');
+            const coordinatorCapabilities = sqliteCoordinator.getCapabilities();
+            // Basic capabilities should match
+            expect(factoryCapabilities.supportsViews).toBe(coordinatorCapabilities.supportsViews);
+            expect(factoryCapabilities.supportsIndexes).toBe(coordinatorCapabilities.supportsIndexes);
+            expect(factoryCapabilities.supportsConstraints).toBe(coordinatorCapabilities.supportsConstraints);
+            expect(factoryCapabilities.supportsForeignKeys).toBe(coordinatorCapabilities.supportsForeignKeys);
+            expect(factoryCapabilities.supportsCheckConstraints).toBe(coordinatorCapabilities.supportsCheckConstraints);
+            expect(factoryCapabilities.supportsDeferredConstraints).toBe(coordinatorCapabilities.supportsDeferredConstraints);
+        });
+    });
+    describe('Feature Support Validation', () => {
+        it('should correctly identify SQLite as supporting basic features', () => {
+            const capabilities = sqliteCoordinator.getCapabilities();
+            expect(capabilities.supportsViews).toBe(true);
+            expect(capabilities.supportsIndexes).toBe(true);
+            expect(capabilities.supportsConstraints).toBe(true);
+            expect(capabilities.supportsForeignKeys).toBe(true);
+            expect(capabilities.supportsCheckConstraints).toBe(true);
+        });
+        it('should correctly identify SQLite limitations', () => {
+            const capabilities = sqliteCoordinator.getCapabilities();
+            expect(capabilities.supportsDeferredConstraints).toBe(false);
+            expect(capabilities.supportsMaterializedViews).toBe(false);
+        });
+    });
+    describe('Capability Usage Examples', () => {
+        it('should demonstrate how to check for specific features', () => {
+            const sqliteCapabilities = sqliteCoordinator.getCapabilities();
+            // Example usage patterns
+            if (sqliteCapabilities.supportsViews) {
+                expect(sqliteCapabilities.supportsViews).toBe(true);
+            }
+            if (sqliteCapabilities.supportsPartialIndexes) {
+                expect(sqliteCapabilities.supportsPartialIndexes).toBe(true);
+            }
+        });
+        it('should demonstrate conditional feature usage', () => {
+            const capabilities = factory.getDialectCapabilities('sqlite');
+            // Simulate conditional logic based on capabilities
+            if (capabilities.supportsViews) {
+                expect(capabilities.supportsViews).toBe(true);
+            }
+            if (capabilities.supportsDeferredConstraints) {
+                // This should not execute for SQLite
+                expect(false).toBe(true);
+            }
+        });
+    });
+});

package/dist/esm/schema/test/discovery-factory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/schema/test/discovery-factory.test.js

@@ -0,0 +1,150 @@
+/// <reference types="./discovery-factory.test.d.ts" />
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { DiscoveryFactory } from '../core/factories/discovery-factory.js';
+import { SQLiteDiscoveryCoordinator } from '../dialects/sqlite/sqlite-discovery.coordinator.js';
+import { SQLiteIndexDiscovery } from '../dialects/sqlite/discovery/sqlite-index-discovery.js';
+import { SQLiteConstraintDiscovery } from '../dialects/sqlite/discovery/sqlite-constraint-discovery.js';
+import { TableMetadataDiscovery } from '../core/discovery/table-metadata-discovery.js';
+import { RelationshipDiscovery } from '../core/discovery/relationship-discovery.js';
+import { ViewDiscovery } from '../core/discovery/view-discovery.js';
+describe('DiscoveryFactory', () => {
+    let factory;
+    beforeEach(() => {
+        // Reset singleton instance for each test
+        ;
+        DiscoveryFactory.instance = undefined;
+        factory = DiscoveryFactory.getInstance();
+    });
+    describe('Singleton Pattern', () => {
+        it('should return the same instance', () => {
+            const instance1 = DiscoveryFactory.getInstance();
+            const instance2 = DiscoveryFactory.getInstance();
+            expect(instance1).toBe(instance2);
+        });
+        it('should maintain state across multiple calls', () => {
+            const instance1 = DiscoveryFactory.getInstance();
+            const instance2 = DiscoveryFactory.getInstance();
+            expect(instance1).toBe(instance2);
+        });
+    });
+    describe('Discovery Service Creation', () => {
+        describe('createTableDiscovery', () => {
+            it('should create TableMetadataDiscovery instance', () => {
+                const discovery = factory.createTableDiscovery();
+                expect(discovery).toBeInstanceOf(TableMetadataDiscovery);
+            });
+            it('should return singleton instance', () => {
+                const discovery1 = factory.createTableDiscovery();
+                const discovery2 = factory.createTableDiscovery();
+                expect(discovery1).toBe(discovery2);
+            });
+        });
+        describe('createRelationshipDiscovery', () => {
+            it('should create RelationshipDiscovery instance', () => {
+                const discovery = factory.createRelationshipDiscovery();
+                expect(discovery).toBeInstanceOf(RelationshipDiscovery);
+            });
+            it('should return singleton instance', () => {
+                const discovery1 = factory.createRelationshipDiscovery();
+                const discovery2 = factory.createRelationshipDiscovery();
+                expect(discovery1).toBe(discovery2);
+            });
+        });
+        describe('createViewDiscovery', () => {
+            it('should create ViewDiscovery instance', () => {
+                const discovery = factory.createViewDiscovery();
+                expect(discovery).toBeInstanceOf(ViewDiscovery);
+            });
+            it('should return singleton instance', () => {
+                const discovery1 = factory.createViewDiscovery();
+                const discovery2 = factory.createViewDiscovery();
+                expect(discovery1).toBe(discovery2);
+            });
+        });
+        describe('createIndexDiscovery', () => {
+            it('should create SQLiteIndexDiscovery for sqlite dialect', () => {
+                const discovery = factory.createIndexDiscovery('sqlite');
+                expect(discovery).toBeInstanceOf(SQLiteIndexDiscovery);
+            });
+            it('should handle case insensitive dialect names', () => {
+                const discovery = factory.createIndexDiscovery('SQLITE');
+                expect(discovery).toBeInstanceOf(SQLiteIndexDiscovery);
+            });
+            it('should throw error for unsupported dialects', () => {
+                expect(() => factory.createIndexDiscovery('unsupported')).toThrow('Unsupported dialect for index discovery: unsupported');
+            });
+        });
+        describe('createConstraintDiscovery', () => {
+            it('should create SQLiteConstraintDiscovery for sqlite dialect', () => {
+                const discovery = factory.createConstraintDiscovery('sqlite');
+                expect(discovery).toBeInstanceOf(SQLiteConstraintDiscovery);
+            });
+            it('should handle case insensitive dialect names', () => {
+                const discovery = factory.createConstraintDiscovery('SQLITE');
+                expect(discovery).toBeInstanceOf(SQLiteConstraintDiscovery);
+            });
+            it('should throw error for unsupported dialects', () => {
+                expect(() => factory.createConstraintDiscovery('unsupported')).toThrow('Unsupported dialect for constraint discovery: unsupported');
+            });
+        });
+        describe('createDiscoveryCoordinator', () => {
+            it('should create SQLiteDiscoveryCoordinator for sqlite dialect', () => {
+                const coordinator = factory.createDiscoveryCoordinator('sqlite');
+                expect(coordinator).toBeInstanceOf(SQLiteDiscoveryCoordinator);
+            });
+            it('should handle case insensitive dialect names', () => {
+                const coordinator = factory.createDiscoveryCoordinator('SQLITE');
+                expect(coordinator).toBeInstanceOf(SQLiteDiscoveryCoordinator);
+            });
+            it('should throw error for unsupported dialects', () => {
+                expect(() => factory.createDiscoveryCoordinator('unsupported')).toThrow('Unsupported dialect for discovery coordinator: unsupported');
+            });
+        });
+        describe('createDiscoveryServices', () => {
+            it('should create all discovery services for sqlite', () => {
+                const services = factory.createDiscoveryServices('sqlite');
+                expect(services.tableDiscovery).toBeInstanceOf(TableMetadataDiscovery);
+                expect(services.relationshipDiscovery).toBeInstanceOf(RelationshipDiscovery);
+                expect(services.viewDiscovery).toBeInstanceOf(ViewDiscovery);
+                expect(services.indexDiscovery).toBeInstanceOf(SQLiteIndexDiscovery);
+                expect(services.constraintDiscovery).toBeInstanceOf(SQLiteConstraintDiscovery);
+            });
+            it('should throw error for unsupported dialects', () => {
+                expect(() => factory.createDiscoveryServices('unsupported')).toThrow('Unsupported dialect for index discovery: unsupported');
+            });
+        });
+    });
+    describe('Dialect Support', () => {
+        it('should return supported dialects', () => {
+            const dialects = factory.getSupportedDialects();
+            expect(dialects).toEqual(['sqlite']);
+        });
+        it('should check if dialect is supported', () => {
+            expect(factory.isDialectSupported('sqlite')).toBe(true);
+            expect(factory.isDialectSupported('SQLITE')).toBe(true);
+            expect(factory.isDialectSupported('unsupported')).toBe(false);
+        });
+        it('should get dialect capabilities', () => {
+            const capabilities = factory.getDialectCapabilities('sqlite');
+            expect(capabilities).toEqual({
+                supportsViews: true,
+                supportsIndexes: true,
+                supportsConstraints: true,
+                supportsForeignKeys: true,
+                supportsCheckConstraints: true,
+                supportsDeferredConstraints: false
+            });
+        });
+        it('should return false capabilities for unsupported dialects', () => {
+            const capabilities = factory.getDialectCapabilities('unsupported');
+            expect(capabilities).toEqual({
+                supportsViews: false,
+                supportsIndexes: false,
+                supportsConstraints: false,
+                supportsForeignKeys: false,
+                supportsCheckConstraints: false,
+                supportsDeferredConstraints: false
+            });
+        });
+    });
+});

package/dist/esm/schema/test/error-handling.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/schema/test/error-handling.test.js

@@ -0,0 +1,148 @@
+/// <reference types="./error-handling.test.d.ts" />
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { DiscoveryFactory } from '../core/factories/discovery-factory.js';
+import { SchemaDiscoveryCoordinator } from '../core/coordinators/schema-discovery.coordinator.js';
+import { SQLiteDiscoveryCoordinator } from '../dialects/sqlite/sqlite-discovery.coordinator.js';
+// Mock console.warn to capture warning messages
+const mockConsoleWarn = jest.spyOn(console, 'warn').mockImplementation(() => { });
+describe('Error Handling', () => {
+    let factory;
+    let coordinator;
+    let sqliteCoordinator;
+    beforeEach(() => {
+        // Reset singleton instances
+        ;
+        DiscoveryFactory.instance = undefined;
+        SchemaDiscoveryCoordinator.instance = undefined;
+        SQLiteDiscoveryCoordinator.instance = undefined;
+        factory = DiscoveryFactory.getInstance();
+        coordinator = SchemaDiscoveryCoordinator.getInstance();
+        sqliteCoordinator = SQLiteDiscoveryCoordinator.getInstance();
+        // Clear console.warn mock calls
+        mockConsoleWarn.mockClear();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('DiscoveryFactory Error Handling', () => {
+        it('should throw error for unsupported dialect in createIndexDiscovery', () => {
+            expect(() => factory.createIndexDiscovery('unsupported')).toThrow('Unsupported dialect for index discovery: unsupported');
+        });
+        it('should throw error for unsupported dialect in createConstraintDiscovery', () => {
+            expect(() => factory.createConstraintDiscovery('unsupported')).toThrow('Unsupported dialect for constraint discovery: unsupported');
+        });
+        it('should throw error for unsupported dialect in createDiscoveryCoordinator', () => {
+            expect(() => factory.createDiscoveryCoordinator('unsupported')).toThrow('Unsupported dialect for discovery coordinator: unsupported');
+        });
+    });
+    describe('SQLite Coordinator Error Handling', () => {
+        const mockKysely = {
+            selectFrom: jest.fn().mockReturnThis(),
+            select: jest.fn().mockReturnThis(),
+            where: jest.fn().mockReturnThis(),
+            execute: jest.fn(),
+            // Add other required Kysely properties as mocks
+            schema: jest.fn(),
+            dynamic: jest.fn(),
+            introspection: jest.fn(),
+            deleteFrom: jest.fn(),
+            insertInto: jest.fn(),
+            updateTable: jest.fn(),
+            with: jest.fn(),
+            withRecursive: jest.fn(),
+            case: jest.fn(),
+            fn: jest.fn(),
+            ref: jest.fn(),
+            raw: jest.fn(),
+            transaction: jest.fn(),
+            replaceInto: jest.fn(),
+            mergeInto: jest.fn(),
+            createSchema: jest.fn(),
+            dropSchema: jest.fn(),
+            createTable: jest.fn(),
+            dropTable: jest.fn(),
+            alterTable: jest.fn(),
+            createIndex: jest.fn(),
+            dropIndex: jest.fn(),
+            createType: jest.fn(),
+            dropType: jest.fn(),
+            createView: jest.fn(),
+            dropView: jest.fn(),
+            createMaterializedView: jest.fn(),
+            dropMaterializedView: jest.fn(),
+            refreshMaterializedView: jest.fn(),
+            executeQuery: jest.fn(),
+            compileQuery: jest.fn(),
+            getExecutor: jest.fn(),
+            getPlugin: jest.fn(),
+            withPlugin: jest.fn(),
+            withoutPlugins: jest.fn(),
+            freeze: jest.fn()
+        };
+        it('should handle table discovery service errors', async () => {
+            // Mock the service to throw an error
+            jest.spyOn(require('../core/discovery/table-metadata-discovery.js'), 'TableMetadataDiscovery')
+                .mockImplementation(() => ({
+                discoverTables: jest.fn().mockRejectedValue(new Error('Table discovery service failed'))
+            }));
+            await expect(sqliteCoordinator.discoverSchema(mockKysely, {})).rejects.toThrow('Table discovery service failed');
+        });
+        it('should handle relationship discovery service errors', async () => {
+            // Mock the service to throw an error
+            jest.spyOn(require('../core/discovery/relationship-discovery.js'), 'RelationshipDiscovery')
+                .mockImplementation(() => ({
+                discoverRelationships: jest.fn().mockRejectedValue(new Error('Relationship discovery service failed'))
+            }));
+            await expect(sqliteCoordinator.discoverSchema(mockKysely, {})).rejects.toThrow('Relationship discovery service failed');
+        });
+        it('should handle index discovery service errors', async () => {
+            // Mock the service to throw an error
+            jest.spyOn(require('../dialects/sqlite/discovery/sqlite-index-discovery.js'), 'SQLiteIndexDiscovery')
+                .mockImplementation(() => ({
+                discoverIndexes: jest.fn().mockRejectedValue(new Error('Index discovery service failed'))
+            }));
+            await expect(sqliteCoordinator.discoverSchema(mockKysely, {})).rejects.toThrow('Index discovery service failed');
+        });
+        it('should handle constraint discovery service errors', async () => {
+            // Mock the service to throw an error
+            jest.spyOn(require('../dialects/sqlite/discovery/sqlite-constraint-discovery.js'), 'SQLiteConstraintDiscovery')
+                .mockImplementation(() => ({
+                discoverConstraints: jest.fn().mockRejectedValue(new Error('Constraint discovery service failed'))
+            }));
+            await expect(sqliteCoordinator.discoverSchema(mockKysely, {})).rejects.toThrow('Constraint discovery service failed');
+        });
+        it('should handle view discovery service errors', async () => {
+            // Mock the service to throw an error
+            jest.spyOn(require('../core/discovery/view-discovery.js'), 'ViewDiscovery')
+                .mockImplementation(() => ({
+                discoverViews: jest.fn().mockRejectedValue(new Error('View discovery service failed'))
+            }));
+            await expect(sqliteCoordinator.discoverSchema(mockKysely, {})).rejects.toThrow('View discovery service failed');
+        });
+        it('should handle database connection errors', async () => {
+            // Mock database to throw connection error
+            const mockKyselyWithError = {
+                selectFrom: jest.fn().mockImplementation(() => {
+                    throw new Error('Database connection failed');
+                })
+            };
+            await expect(sqliteCoordinator.discoverSchema(mockKyselyWithError, {})).rejects.toThrow('Database connection failed');
+        });
+    });
+    describe('Error Message Formatting', () => {
+        it('should provide helpful error messages', () => {
+            const error = new Error('Database connection failed');
+            expect(error.message).toBe('Database connection failed');
+        });
+        it('should handle undefined error gracefully', () => {
+            expect(() => {
+                throw undefined;
+            }).toThrow();
+        });
+        it('should handle null error gracefully', () => {
+            expect(() => {
+                throw null;
+            }).toThrow();
+        });
+    });
+});

package/dist/esm/schema/test/integration.test.d.ts

@@ -0,0 +1 @@
+export {};