refactor: migrate all connection modes to multi-source architecture (#128)

* refactor: migrate all connection modes to multi-source architecture

This commit removes the legacy single-DSN mode and unifies all connection
methods (demo, CLI DSN, TOML) to use the multi-source architecture. All
database sources are now exposed via the /api/sources endpoint.

Key changes:
- Demo mode now uses connectWithSources() with proper SourceConfig
- Single DSN mode assigns id="default" and type from DSN protocol
- Removed legacy fields: activeConnector, connected, sshTunnel, originalDSN, maxRows
- Removed legacy methods: connectWithDSN(), connectWithType(), isConnected()
- Updated SSH tunnel tests to use connectWithSources()
- Added init_script field to SourceConfig for demo database initialization

Benefits:
- Single unified code path for all connection modes
- All sources properly registered and queryable via API
- Cleaner architecture with ~120 lines of legacy code removed
- Consistent behavior across demo, CLI DSN, and TOML configurations

Test coverage: 38/38 integration tests passing

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

* fix: apply execution options to demo mode source config

Apply readonly and max_rows execution options to demoSource before
calling connectWithSources(), ensuring consistency with how single DSN
mode handles these options in env.ts (lines 525-528).

This ensures that --readonly and --max-rows flags work correctly in
demo mode, with the options properly stored in executeOptions map.

Addresses review feedback from PR #128.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: tianzhou

src/config/demo-loader.ts

@@ -74,4 +74,4 @@ export function getSqliteInMemorySetupSql(): string {
   }
 
   return sql;
-}
+}

src/config/env.ts

@@ -472,7 +472,7 @@ export function resolveSSHConfig(): { config: SSHTunnelConfig; source: string }
  * Priority: TOML config (--config flag or ./dbhub.toml) > single DSN/env vars
  * Returns array of source configs and the source of the configuration
  */
-export function resolveSourceConfigs(): { sources: SourceConfig[]; source: string } | null {
+export async function resolveSourceConfigs(): Promise<{ sources: SourceConfig[]; source: string } | null> {
   // 1. Try loading from TOML configuration file (highest priority for multi-source)
   const tomlConfig = loadTomlConfig();
   if (tomlConfig) {
@@ -482,10 +482,39 @@ export function resolveSourceConfigs(): { sources: SourceConfig[]; source: strin
   // 2. Fallback to single DSN configuration for backward compatibility
   const dsnResult = resolveDSN();
   if (dsnResult) {
+    // Parse DSN to extract database type
+    let dsnUrl: URL;
+    try {
+      dsnUrl = new URL(dsnResult.dsn);
+    } catch (error) {
+      throw new Error(
+        `Invalid DSN format: ${dsnResult.dsn}. Expected format: protocol://[user[:password]@]host[:port]/database`
+      );
+    }
+
+    const protocol = dsnUrl.protocol.replace(':', '');
+
+    // Map protocol to database type
+    let dbType: "postgres" | "mysql" | "mariadb" | "sqlserver" | "sqlite";
+    if (protocol === 'postgresql' || protocol === 'postgres') {
+      dbType = 'postgres';
+    } else if (protocol === 'mysql') {
+      dbType = 'mysql';
+    } else if (protocol === 'mariadb') {
+      dbType = 'mariadb';
+    } else if (protocol === 'sqlserver') {
+      dbType = 'sqlserver';
+    } else if (protocol === 'sqlite') {
+      dbType = 'sqlite';
+    } else {
+      throw new Error(`Unsupported database type in DSN: ${protocol}`);
+    }
+
     // Create a single source config from the resolved DSN
-    // Use empty string as ID for backward compatibility (default/unnamed source)
+    // Use "default" as ID so it appears in the API sources list
     const source: SourceConfig = {
-      id: "",
+      id: "default",
+      type: dbType,
       dsn: dsnResult.dsn,
     };
 
@@ -507,6 +536,12 @@ export function resolveSourceConfigs(): { sources: SourceConfig[]; source: strin
       source.max_rows = maxRowsResult.maxRows;
     }
 
+    // Add init script for demo mode
+    if (dsnResult.isDemo) {
+      const { getSqliteInMemorySetupSql } = await import('./demo-loader.js');
+      source.init_script = getSqliteInMemorySetupSql();
+    }
+
     return {
       sources: [source],
       source: dsnResult.isDemo ? "demo mode" : dsnResult.source,

src/connectors/__tests__/postgres-ssh.integration.test.ts

@@ -5,8 +5,19 @@ import { ConnectorManager } from '../manager.js';
 import { ConnectorRegistry } from '../interface.js';
 import { SSHTunnel } from '../../utils/ssh-tunnel.js';
 import type { SSHTunnelConfig } from '../../types/ssh.js';
+import type { SourceConfig } from '../../types/config.js';
 import * as sshConfigParser from '../../utils/ssh-config-parser.js';
 
+/**
+ * Helper function to create a SourceConfig from a DSN for testing
+ */
+function createSourceConfigFromDSN(dsn: string, sourceId: string = 'test'): SourceConfig {
+  return {
+    id: sourceId,
+    dsn: dsn,
+  };
+}
+
 describe('PostgreSQL SSH Tunnel Simple Integration Tests', () => {
   let postgresContainer: StartedPostgreSqlContainer;
 
@@ -60,161 +71,119 @@ describe('PostgreSQL SSH Tunnel Simple Integration Tests', () => {
 
       // Make sure no SSH config is set
       delete process.env.SSH_HOST;
-      
+
       const dsn = postgresContainer.getConnectionUri();
-      
-      await manager.connectWithDSN(dsn);
-      
+      const sourceConfig = createSourceConfigFromDSN(dsn);
+
+      await manager.connectWithSources([sourceConfig]);
+
       // Test that connection works
       const connector = manager.getConnector();
       const result = await connector.executeSQL('SELECT 1 as test', {});
       expect(result.rows).toHaveLength(1);
       expect(result.rows[0].test).toBe(1);
-      
+
       await manager.disconnect();
     });
 
     it('should fail gracefully when SSH config is invalid', async () => {
       const manager = new ConnectorManager();
-      
-      // Set invalid SSH config (missing required fields)
-      process.env.SSH_HOST = 'example.com';
-      // Missing SSH_USER
-      
-      try {
-        const dsn = postgresContainer.getConnectionUri();
-        await expect(manager.connectWithDSN(dsn)).rejects.toThrow(/SSH tunnel configuration requires/);
-      } finally {
-        delete process.env.SSH_HOST;
-      }
+
+      // Create source config with invalid SSH config (missing required fields)
+      const dsn = postgresContainer.getConnectionUri();
+      const sourceConfig = createSourceConfigFromDSN(dsn);
+      sourceConfig.ssh_host = 'example.com';
+      // Missing ssh_user
+
+      await expect(manager.connectWithSources([sourceConfig])).rejects.toThrow(/SSH tunnel requires ssh_user/);
     });
 
     it('should validate SSH authentication method', async () => {
       const manager = new ConnectorManager();
-      
-      // Set SSH config without authentication method
-      process.env.SSH_HOST = 'example.com';
-      process.env.SSH_USER = 'testuser';
-      // Missing both SSH_PASSWORD and SSH_KEY
-      
-      try {
-        const dsn = postgresContainer.getConnectionUri();
-        await expect(manager.connectWithDSN(dsn)).rejects.toThrow(/SSH tunnel configuration requires either/);
-      } finally {
-        delete process.env.SSH_HOST;
-        delete process.env.SSH_USER;
-      }
+
+      // Create source config with SSH but without authentication method
+      const dsn = postgresContainer.getConnectionUri();
+      const sourceConfig = createSourceConfigFromDSN(dsn);
+      sourceConfig.ssh_host = 'example.com';
+      sourceConfig.ssh_user = 'testuser';
+      // Missing both ssh_password and ssh_key
+
+      await expect(manager.connectWithSources([sourceConfig])).rejects.toThrow(/SSH tunnel requires either ssh_password or ssh_key/);
     });
 
-    it('should handle SSH config file resolution', async () => {
+    it('should handle SSH tunnel with source config', async () => {
       const manager = new ConnectorManager();
-      
-      // Mock the SSH config parser functions
-      const mockParseSSHConfig = vi.spyOn(sshConfigParser, 'parseSSHConfig');
-      const mockLooksLikeSSHAlias = vi.spyOn(sshConfigParser, 'looksLikeSSHAlias');
-      
+
       // Spy on the SSH tunnel establish method to verify the config values
       const mockSSHTunnelEstablish = vi.spyOn(SSHTunnel.prototype, 'establish');
-      
+
       try {
-        // Configure mocks to simulate SSH config file lookup with specific values
-        mockLooksLikeSSHAlias.mockReturnValue(true);
-        mockParseSSHConfig.mockReturnValue({
-          host: 'bastion.example.com',
-          username: 'sshuser',
-          port: 2222,
-          privateKey: '/home/user/.ssh/id_rsa'
-        });
-        
         // Mock SSH tunnel establish to capture the config and prevent actual connection
         mockSSHTunnelEstablish.mockRejectedValue(new Error('SSH connection failed (expected in test)'));
-        
-        // Set SSH host alias (would normally come from command line)
-        process.env.SSH_HOST = 'mybastion';
-        
+
         const dsn = postgresContainer.getConnectionUri();
-        
-        // This should fail during SSH connection (expected), but we can verify the config parsing
-        await expect(manager.connectWithDSN(dsn)).rejects.toThrow();
-        
-        // Verify that SSH config parsing functions were called correctly
-        expect(mockLooksLikeSSHAlias).toHaveBeenCalledWith('mybastion');
-        expect(mockParseSSHConfig).toHaveBeenCalledWith('mybastion', expect.stringContaining('.ssh/config'));
-        
-        // Verify that SSH tunnel was attempted with the correct config values from SSH config
+        const sourceConfig = createSourceConfigFromDSN(dsn);
+
+        // Configure SSH tunnel via source config
+        sourceConfig.ssh_host = 'bastion.example.com';
+        sourceConfig.ssh_user = 'sshuser';
+        sourceConfig.ssh_port = 2222;
+        sourceConfig.ssh_key = '/home/user/.ssh/id_rsa';
+
+        // This should fail during SSH connection (expected), but we can verify the config
+        await expect(manager.connectWithSources([sourceConfig])).rejects.toThrow();
+
+        // Verify that SSH tunnel was attempted with the correct config values
         expect(mockSSHTunnelEstablish).toHaveBeenCalledTimes(1);
         const sshTunnelCall = mockSSHTunnelEstablish.mock.calls[0];
         const [sshConfig, tunnelOptions] = sshTunnelCall;
-        
-        // Debug: Log the actual values being passed (for verification)
-        // SSH Config should contain the values from our mocked SSH config file
-        // Tunnel Options should contain database connection details from the container DSN
-        
-        // Verify SSH config values were properly resolved from the SSH config file
+
+        // Verify SSH config values were properly set from source config
         expect(sshConfig).toMatchObject({
-          host: 'bastion.example.com',    // Should use HostName from SSH config
-          username: 'sshuser',           // Should use User from SSH config  
-          port: 2222,                    // Should use Port from SSH config
-          privateKey: '/home/user/.ssh/id_rsa' // Should use IdentityFile from SSH config
+          host: 'bastion.example.com',
+          username: 'sshuser',
+          port: 2222,
+          privateKey: '/home/user/.ssh/id_rsa'
         });
-        
+
         // Verify tunnel options are correctly set up for the database connection
-        expect(tunnelOptions).toMatchObject({
-          targetHost: expect.any(String), // Database host from DSN
-          targetPort: expect.any(Number)  // Database port from DSN
-        });
-        
-        // The localPort might be undefined for dynamic allocation, so check separately if it exists
-        if (tunnelOptions.localPort !== undefined) {
-          expect(typeof tunnelOptions.localPort).toBe('number');
-        }
-        
-        // Verify that the target database details from the DSN are preserved
         const originalDsnUrl = new URL(dsn);
         expect(tunnelOptions.targetHost).toBe(originalDsnUrl.hostname);
         expect(tunnelOptions.targetPort).toBe(parseInt(originalDsnUrl.port));
-        
+
       } finally {
-        // Clean up
-        delete process.env.SSH_HOST;
-        mockParseSSHConfig.mockRestore();
-        mockLooksLikeSSHAlias.mockRestore();
         mockSSHTunnelEstablish.mockRestore();
       }
     });
 
-    it('should skip SSH config lookup for direct hostnames', async () => {
+    it('should handle SSH tunnel with password authentication', async () => {
       const manager = new ConnectorManager();
-      
-      // Mock the SSH config parser functions
-      const mockParseSSHConfig = vi.spyOn(sshConfigParser, 'parseSSHConfig');
-      const mockLooksLikeSSHAlias = vi.spyOn(sshConfigParser, 'looksLikeSSHAlias');
-      
+
+      // Spy on the SSH tunnel establish method
+      const mockSSHTunnelEstablish = vi.spyOn(SSHTunnel.prototype, 'establish');
+
       try {
-        // Configure mocks - direct hostname should not trigger SSH config lookup
-        mockLooksLikeSSHAlias.mockReturnValue(false);
-        
-        // Set a direct hostname with required SSH credentials
-        process.env.SSH_HOST = 'ssh.example.com';
-        process.env.SSH_USER = 'sshuser';
-        process.env.SSH_PASSWORD = 'sshpass';
-        
+        // Mock SSH tunnel establish to prevent actual connection
+        mockSSHTunnelEstablish.mockRejectedValue(new Error('SSH connection failed (expected in test)'));
+
         const dsn = postgresContainer.getConnectionUri();
-        
-        // This should fail during actual SSH connection, but we can verify the parsing behavior
-        await expect(manager.connectWithDSN(dsn)).rejects.toThrow();
-        
-        // Verify that SSH config parsing was checked but not executed
-        expect(mockLooksLikeSSHAlias).toHaveBeenCalledWith('ssh.example.com');
-        expect(mockParseSSHConfig).not.toHaveBeenCalled();
-        
+        const sourceConfig = createSourceConfigFromDSN(dsn);
+
+        // Configure SSH tunnel with password authentication
+        sourceConfig.ssh_host = 'ssh.example.com';
+        sourceConfig.ssh_user = 'sshuser';
+        sourceConfig.ssh_password = 'sshpass';
+
+        // This should fail during actual SSH connection
+        await expect(manager.connectWithSources([sourceConfig])).rejects.toThrow();
+
+        // Verify SSH tunnel was attempted with password auth
+        expect(mockSSHTunnelEstablish).toHaveBeenCalledTimes(1);
+        const [sshConfig] = mockSSHTunnelEstablish.mock.calls[0];
+        expect(sshConfig.password).toBe('sshpass');
+
       } finally {
-        // Clean up
-        delete process.env.SSH_HOST;
-        delete process.env.SSH_USER;
-        delete process.env.SSH_PASSWORD;
-        mockParseSSHConfig.mockRestore();
-        mockLooksLikeSSHAlias.mockRestore();
+        mockSSHTunnelEstablish.mockRestore();
       }
     });
   });