Connection dialog improvments. Revert provider lazy loading

Author: Maxteabag

.github/workflows/release.yml

@@ -104,7 +104,8 @@ jobs:
       - name: Setup SSH for AUR
         run: |
           mkdir -p ~/.ssh
-          echo "${{ secrets.AUR_SSH_KEY }}" > ~/.ssh/aur
+          # Decode base64-encoded SSH key (encode with: base64 -w 0 < ~/.ssh/aur_key)
+          echo "${{ secrets.AUR_SSH_KEY }}" | base64 -d > ~/.ssh/aur
           chmod 600 ~/.ssh/aur
           echo "Host aur.archlinux.org" >> ~/.ssh/config
           echo "  IdentityFile ~/.ssh/aur" >> ~/.ssh/config

sqlit/db/providers.py

@@ -1,4 +1,4 @@
-"""Canonical provider registry (Plan B).
+"""Canonical provider registry.
 
 This module is the single source of truth for:
 - supported provider ids (db_type)
@@ -8,67 +8,61 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterable
 from dataclasses import dataclass
-from importlib import import_module
 from typing import TYPE_CHECKING
 
+# Pre-import all schemas (no external dependencies)
+from .schema import (
+    COCKROACHDB_SCHEMA,
+    D1_SCHEMA,
+    DUCKDB_SCHEMA,
+    MARIADB_SCHEMA,
+    MSSQL_SCHEMA,
+    MYSQL_SCHEMA,
+    ORACLE_SCHEMA,
+    POSTGRESQL_SCHEMA,
+    SQLITE_SCHEMA,
+    SUPABASE_SCHEMA,
+    TURSO_SCHEMA,
+    ConnectionSchema,
+)
+
+# Pre-import all adapter classes (they lazy-load their dependencies internally)
+from .adapters.cockroachdb import CockroachDBAdapter
+from .adapters.d1 import D1Adapter
+from .adapters.duckdb import DuckDBAdapter
+from .adapters.mariadb import MariaDBAdapter
+from .adapters.mssql import SQLServerAdapter
+from .adapters.mysql import MySQLAdapter
+from .adapters.oracle import OracleAdapter
+from .adapters.postgresql import PostgreSQLAdapter
+from .adapters.sqlite import SQLiteAdapter
+from .adapters.supabase import SupabaseAdapter
+from .adapters.turso import TursoAdapter
+
 if TYPE_CHECKING:
-    from collections.abc import Iterable
     from .adapters.base import DatabaseAdapter
-    from .schema import ConnectionSchema
 
 
 @dataclass(frozen=True)
 class ProviderSpec:
-    schema_path: tuple[str, str]
-    adapter_path: tuple[str, str]
+    schema: ConnectionSchema
+    adapter_class: type["DatabaseAdapter"]
 
 
 PROVIDERS: dict[str, ProviderSpec] = {
-    "mssql": ProviderSpec(
-        schema_path=("sqlit.db.schema", "MSSQL_SCHEMA"),
-        adapter_path=("sqlit.db.adapters.mssql", "SQLServerAdapter"),
-    ),
-    "sqlite": ProviderSpec(
-        schema_path=("sqlit.db.schema", "SQLITE_SCHEMA"),
-        adapter_path=("sqlit.db.adapters.sqlite", "SQLiteAdapter"),
-    ),
-    "postgresql": ProviderSpec(
-        schema_path=("sqlit.db.schema", "POSTGRESQL_SCHEMA"),
-        adapter_path=("sqlit.db.adapters.postgresql", "PostgreSQLAdapter"),
-    ),
-    "mysql": ProviderSpec(
-        schema_path=("sqlit.db.schema", "MYSQL_SCHEMA"),
-        adapter_path=("sqlit.db.adapters.mysql", "MySQLAdapter"),
-    ),
-    "oracle": ProviderSpec(
-        schema_path=("sqlit.db.schema", "ORACLE_SCHEMA"),
-        adapter_path=("sqlit.db.adapters.oracle", "OracleAdapter"),
-    ),
-    "mariadb": ProviderSpec(
-        schema_path=("sqlit.db.schema", "MARIADB_SCHEMA"),
-        adapter_path=("sqlit.db.adapters.mariadb", "MariaDBAdapter"),
-    ),
-    "duckdb": ProviderSpec(
-        schema_path=("sqlit.db.schema", "DUCKDB_SCHEMA"),
-        adapter_path=("sqlit.db.adapters.duckdb", "DuckDBAdapter"),
-    ),
-    "cockroachdb": ProviderSpec(
-        schema_path=("sqlit.db.schema", "COCKROACHDB_SCHEMA"),
-        adapter_path=("sqlit.db.adapters.cockroachdb", "CockroachDBAdapter"),
-    ),
-    "turso": ProviderSpec(
-        schema_path=("sqlit.db.schema", "TURSO_SCHEMA"),
-        adapter_path=("sqlit.db.adapters.turso", "TursoAdapter"),
-    ),
-    "supabase": ProviderSpec(
-        schema_path=("sqlit.db.schema", "SUPABASE_SCHEMA"),
-        adapter_path=("sqlit.db.adapters.supabase", "SupabaseAdapter"),
-    ),
-    "d1": ProviderSpec(
-        schema_path=("sqlit.db.schema", "D1_SCHEMA"),
-        adapter_path=("sqlit.db.adapters.d1", "D1Adapter"),
-    ),
+    "mssql": ProviderSpec(schema=MSSQL_SCHEMA, adapter_class=SQLServerAdapter),
+    "sqlite": ProviderSpec(schema=SQLITE_SCHEMA, adapter_class=SQLiteAdapter),
+    "postgresql": ProviderSpec(schema=POSTGRESQL_SCHEMA, adapter_class=PostgreSQLAdapter),
+    "mysql": ProviderSpec(schema=MYSQL_SCHEMA, adapter_class=MySQLAdapter),
+    "oracle": ProviderSpec(schema=ORACLE_SCHEMA, adapter_class=OracleAdapter),
+    "mariadb": ProviderSpec(schema=MARIADB_SCHEMA, adapter_class=MariaDBAdapter),
+    "duckdb": ProviderSpec(schema=DUCKDB_SCHEMA, adapter_class=DuckDBAdapter),
+    "cockroachdb": ProviderSpec(schema=COCKROACHDB_SCHEMA, adapter_class=CockroachDBAdapter),
+    "turso": ProviderSpec(schema=TURSO_SCHEMA, adapter_class=TursoAdapter),
+    "supabase": ProviderSpec(schema=SUPABASE_SCHEMA, adapter_class=SupabaseAdapter),
+    "d1": ProviderSpec(schema=D1_SCHEMA, adapter_class=D1Adapter),
 }
 
 
@@ -77,7 +71,7 @@ def get_supported_db_types() -> list[str]:
 
 
 def iter_provider_schemas() -> Iterable[ConnectionSchema]:
-    return (_get_schema(spec) for spec in PROVIDERS.values())
+    return (spec.schema for spec in PROVIDERS.values())
 
 
 def get_provider_spec(db_type: str) -> ProviderSpec:
@@ -87,18 +81,12 @@ def get_provider_spec(db_type: str) -> ProviderSpec:
     return spec
 
 
-def _get_schema(spec: ProviderSpec) -> ConnectionSchema:
-    module_name, attr_name = spec.schema_path
-    module = import_module(module_name)
-    return getattr(module, attr_name)
-
-
 def get_connection_schema(db_type: str) -> ConnectionSchema:
-    return _get_schema(get_provider_spec(db_type))
+    return get_provider_spec(db_type).schema
 
 
 def get_all_schemas() -> dict[str, ConnectionSchema]:
-    return {k: _get_schema(v) for k, v in PROVIDERS.items()}
+    return {k: v.schema for k, v in PROVIDERS.items()}
 
 
 def get_adapter(db_type: str) -> "DatabaseAdapter":
@@ -109,35 +97,31 @@ def get_adapter(db_type: str) -> "DatabaseAdapter":
 
 
 def get_adapter_class(db_type: str) -> type["DatabaseAdapter"]:
-    spec = get_provider_spec(db_type)
-    module_name, class_name = spec.adapter_path
-    module = import_module(module_name)
-    adapter_cls = getattr(module, class_name)
-    return adapter_cls
+    return get_provider_spec(db_type).adapter_class
 
 
 def get_default_port(db_type: str) -> str:
     spec = PROVIDERS.get(db_type)
     if spec is None:
         return "1433"
-    return _get_schema(spec).default_port
+    return spec.schema.default_port
 
 
 def get_display_name(db_type: str) -> str:
     spec = PROVIDERS.get(db_type)
-    return _get_schema(spec).display_name if spec else db_type
+    return spec.schema.display_name if spec else db_type
 
 
 def supports_ssh(db_type: str) -> bool:
     spec = PROVIDERS.get(db_type)
-    return _get_schema(spec).supports_ssh if spec else False
+    return spec.schema.supports_ssh if spec else False
 
 
 def is_file_based(db_type: str) -> bool:
     spec = PROVIDERS.get(db_type)
-    return _get_schema(spec).is_file_based if spec else False
+    return spec.schema.is_file_based if spec else False
 
 
 def has_advanced_auth(db_type: str) -> bool:
     spec = PROVIDERS.get(db_type)
-    return _get_schema(spec).has_advanced_auth if spec else False
+    return spec.schema.has_advanced_auth if spec else False

sqlit/ui/mixins/connection.py

@@ -299,10 +299,15 @@ def handle_connection_result(self: AppProtocol, result: tuple | None) -> None:
         if not result:
             return
 
-        action, config = result
+        action, config = result[0], result[1]
+        original_name = result[2] if len(result) > 2 else None
 
         if action == "save":
-            def do_save(with_config) -> None:  # noqa: ANN001
+            def do_save(with_config, orig_name=None) -> None:  # noqa: ANN001
+                # When editing, remove by original name to properly update renamed connections
+                if orig_name:
+                    self.connections = [c for c in self.connections if c.name != orig_name]
+                # Also remove by new name to handle overwrites/duplicates
                 self.connections = [c for c in self.connections if c.name != with_config.name]
                 self.connections.append(with_config)
                 if getattr(self, "_mock_profile", None):
@@ -319,13 +324,13 @@ def do_save(with_config) -> None:  # noqa: ANN001
 
                 if allow_plaintext is True:
                     reset_credentials_service()
-                    do_save(config)
+                    do_save(config, original_name)
                     return
 
                 if allow_plaintext is False:
                     config.password = ""
                     config.ssh_password = ""
-                    do_save(config)
+                    do_save(config, original_name)
                     self.notify("Keyring unavailable: passwords will be prompted when needed", severity="warning")
                     return
 
@@ -335,15 +340,15 @@ def on_confirm(confirmed: bool | None) -> None:
                         settings2[ALLOW_PLAINTEXT_CREDENTIALS_SETTING] = True
                         save_settings(settings2)
                         reset_credentials_service()
-                        do_save(config)
+                        do_save(config, original_name)
                         self.notify("Saved passwords as plaintext in ~/.sqlit/ (0600)", severity="warning")
                         return
 
                     settings2[ALLOW_PLAINTEXT_CREDENTIALS_SETTING] = False
                     save_settings(settings2)
                     config.password = ""
                     config.ssh_password = ""
-                    do_save(config)
+                    do_save(config, original_name)
                     self.notify("Passwords were not saved (keyring unavailable)", severity="warning")
 
                 self.push_screen(
@@ -357,7 +362,7 @@ def on_confirm(confirmed: bool | None) -> None:
                 )
                 return
 
-            do_save(config)
+            do_save(config, original_name)
 
     def action_duplicate_connection(self: AppProtocol) -> None:
         from dataclasses import replace

sqlit/ui/screens/__init__.py

@@ -1,7 +1,18 @@
 """Modal screens for sqlit."""
 
-from importlib import import_module
-from typing import TYPE_CHECKING, Any
+from .confirm import ConfirmScreen
+from .connection import ConnectionScreen
+from .connection_picker import ConnectionPickerScreen
+from .driver_setup import DriverSetupScreen
+from .error import ErrorScreen
+from .help import HelpScreen
+from .leader_menu import LeaderMenuScreen
+from .message import MessageScreen
+from .package_setup import PackageSetupScreen
+from .password_input import PasswordInputScreen
+from .query_history import QueryHistoryScreen
+from .theme import ThemeScreen
+from .value_view import ValueViewScreen
 
 __all__ = [
     "ConfirmScreen",
@@ -18,43 +29,3 @@
     "ThemeScreen",
     "ValueViewScreen",
 ]
-
-_LAZY_ATTRS: dict[str, tuple[str, str]] = {
-    "ConfirmScreen": ("sqlit.ui.screens.confirm", "ConfirmScreen"),
-    "ConnectionScreen": ("sqlit.ui.screens.connection", "ConnectionScreen"),
-    "ConnectionPickerScreen": ("sqlit.ui.screens.connection_picker", "ConnectionPickerScreen"),
-    "DriverSetupScreen": ("sqlit.ui.screens.driver_setup", "DriverSetupScreen"),
-    "ErrorScreen": ("sqlit.ui.screens.error", "ErrorScreen"),
-    "HelpScreen": ("sqlit.ui.screens.help", "HelpScreen"),
-    "LeaderMenuScreen": ("sqlit.ui.screens.leader_menu", "LeaderMenuScreen"),
-    "MessageScreen": ("sqlit.ui.screens.message", "MessageScreen"),
-    "PackageSetupScreen": ("sqlit.ui.screens.package_setup", "PackageSetupScreen"),
-    "PasswordInputScreen": ("sqlit.ui.screens.password_input", "PasswordInputScreen"),
-    "QueryHistoryScreen": ("sqlit.ui.screens.query_history", "QueryHistoryScreen"),
-    "ThemeScreen": ("sqlit.ui.screens.theme", "ThemeScreen"),
-    "ValueViewScreen": ("sqlit.ui.screens.value_view", "ValueViewScreen"),
-}
-
-if TYPE_CHECKING:
-    from .confirm import ConfirmScreen
-    from .connection import ConnectionScreen
-    from .connection_picker import ConnectionPickerScreen
-    from .driver_setup import DriverSetupScreen
-    from .error import ErrorScreen
-    from .help import HelpScreen
-    from .leader_menu import LeaderMenuScreen
-    from .message import MessageScreen
-    from .package_setup import PackageSetupScreen
-    from .password_input import PasswordInputScreen
-    from .query_history import QueryHistoryScreen
-    from .theme import ThemeScreen
-    from .value_view import ValueViewScreen
-
-
-def __getattr__(name: str) -> Any:
-    target = _LAZY_ATTRS.get(name)
-    if target is None:
-        raise AttributeError(name)
-    module_name, attr_name = target
-    module = import_module(module_name)
-    return getattr(module, attr_name)