Refactoring - Add mock layer for connections and queries

Author: Maxteabag

README.md

@@ -1,6 +1,6 @@
 # sqlit
 
-**The lazygit of SQL databases.** Connect to Postgres, MySQL, SQL Server, SQLite, Turso, and more from your terminal in seconds.
+**The lazygit of SQL databases.** Connect to Postgres, MySQL, SQL Server, SQLite, Supabase, Turso, and more from your terminal in seconds.
 
 A lightweight TUI for people who just want to run some queries fast.
 
@@ -18,7 +18,7 @@ A lightweight TUI for people who just want to run some queries fast.
 
 - **Connection manager UI** - Save connections, switch between databases without CLI args
 - **Just run `sqlit`** - No CLI config needed, pick a connection and go
-- **Multi-database out of the box** - SQL Server, PostgreSQL, MySQL, SQLite, MariaDB, Oracle, DuckDB, CockroachDB, Turso - no adapters to install
+- **Multi-database out of the box** - SQL Server, PostgreSQL, MySQL, SQLite, MariaDB, Oracle, DuckDB, CockroachDB, Supabase, Turso - no adapters to install
 - **SSH tunnels built-in** - Connect to remote databases securely with password or key auth
 - **Vim-style editing** - Modal editing for terminal purists
 - **Query history** - Automatically saves queries per connection, searchable and sortable
@@ -40,7 +40,7 @@ The problem got severely worse when I switched to Linux and had to rely on VS CO
 
 I tried to use some existing TUI's for SQL, but they were not intuitive for me and I missed the immediate ease of use that other TUI's such as Lazygit provides.
 
-sqlit is a lightweight database TUI that is easy to use and beautiful to look at, just connect and query. It's for you that just wants to run queries toward your database without launching applications that eats your ram and takes time to load up. Sqlit supports SQL Server, PostgreSQL, MySQL, SQLite, MariaDB, Oracle, DuckDB, CockroachDB, and Turso, and is designed to make it easy and enjoyable to access your data, not painful.
+sqlit is a lightweight database TUI that is easy to use and beautiful to look at, just connect and query. It's for you that just wants to run queries toward your database without launching applications that eats your ram and takes time to load up. Sqlit supports SQL Server, PostgreSQL, MySQL, SQLite, MariaDB, Oracle, DuckDB, CockroachDB, Supabase, and Turso, and is designed to make it easy and enjoyable to access your data, not painful.
 
 
 ## Installation
@@ -59,6 +59,14 @@ sqlit
 
 The keybindings are shown at the bottom of the screen.
 
+### Try it without a database
+
+Want to explore the UI without connecting to a real database? Run with mock data:
+
+```bash
+sqlit --mock=sqlite-demo
+```
+
 ### CLI
 
 ```bash
@@ -161,6 +169,7 @@ Each database provider requires specific Python packages. sqlit will prompt you
 | Oracle | `oracledb` | `pip install oracledb` |
 | DuckDB | `duckdb` | `pip install duckdb` |
 | CockroachDB | `psycopg2-binary` | `pip install psycopg2-binary` |
+| Supabase | `psycopg2-binary` | `pip install psycopg2-binary` |
 | Turso | `libsql-client` | `pip install libsql-client` |
 
 **Note:** SQL Server also requires the ODBC driver. On first connection attempt, sqlit will detect if it's missing and help you install it.

demo-sqlite.gif

@@ -23,10 +23,9 @@
     save_settings,
 )
 from .db import DatabaseAdapter
+from .mocks import MockProfile
 from .state_machine import (
     get_leader_bindings,
-    get_leader_binding_actions,
-    check_leader_action_guard,
     UIStateMachine,
 )
 from .ui.mixins import (
@@ -215,8 +214,9 @@ class SSMSTUI(
         Binding("ctrl+c", "cancel_operation", "Cancel", show=False),
     ]
 
-    def __init__(self):
+    def __init__(self, mock_profile: MockProfile | None = None):
         super().__init__()
+        self._mock_profile = mock_profile
         self.connections: list[ConnectionConfig] = []
         self.current_connection: Any | None = None
         self.current_config: ConnectionConfig | None = None
@@ -264,6 +264,30 @@ def __init__(self):
         self._columns_loading: set[str] = set()
         self._state_machine = UIStateMachine()
 
+        if mock_profile:
+            self._session_factory = self._create_mock_session_factory(mock_profile)
+
+    def _create_mock_session_factory(self, profile: MockProfile):
+        """Create a session factory that uses mock adapters."""
+        from .services import ConnectionSession
+
+        def mock_adapter_factory(db_type: str):
+            """Return mock adapter for the given db type."""
+            return profile.get_adapter(db_type)
+
+        def mock_tunnel_factory(config):
+            """Return no tunnel for mock connections."""
+            return None, config.server, int(config.port or "0")
+
+        def factory(config):
+            return ConnectionSession.create(
+                config,
+                adapter_factory=mock_adapter_factory,
+                tunnel_factory=mock_tunnel_factory,
+            )
+
+        return factory
+
     @property
     def object_tree(self) -> Tree:
         return self.query_one("#object-tree", Tree)
@@ -314,16 +338,11 @@ def pop_screen(self):
         return result
 
     def check_action(self, action: str, parameters: tuple) -> bool | None:
-        """Check if an action is allowed in the current state."""
-        if action in get_leader_binding_actions():
-            if not getattr(self, "_leader_pending", False):
-                return False
-            if hasattr(self, "_leader_timer") and self._leader_timer is not None:
-                self._leader_timer.stop()
-                self._leader_timer = None
-            self._leader_pending = False
-            return check_leader_action_guard(self, action)
+        """Check if an action is allowed in the current state.
 
+        This method is pure - it only checks, never mutates state.
+        State transitions happen in the action methods themselves.
+        """
         return self._state_machine.check_action(self, action)
 
     def compose(self) -> ComposeResult:
@@ -363,7 +382,7 @@ def compose(self) -> ComposeResult:
 
     def on_mount(self) -> None:
         """Initialize the app."""
-        if not PYODBC_AVAILABLE:
+        if not PYODBC_AVAILABLE and not self._mock_profile:
             self.notify(
                 "pyodbc not installed. Run: pip install pyodbc",
                 severity="warning",
@@ -382,7 +401,11 @@ def on_mount(self) -> None:
         settings = load_settings()
         self._expanded_paths = set(settings.get("expanded_nodes", []))
 
-        self.connections = load_connections()
+        if self._mock_profile:
+            self.connections = self._mock_profile.connections.copy()
+        else:
+            self.connections = load_connections()
+
         self.refresh_tree()
         self._update_footer_bindings()
 
@@ -392,8 +415,8 @@ def on_mount(self) -> None:
             self.object_tree.cursor_line = 0
         self._update_section_labels()
 
-        # Check for ODBC drivers
-        self._check_drivers()
+        if not self._mock_profile:
+            self._check_drivers()
 
     def _check_drivers(self) -> None:
         """Check if ODBC drivers are installed and show setup if needed."""

demo.db

@@ -15,6 +15,14 @@ def main() -> int:
         prog="sqlit",
         description="A terminal UI for SQL Server, PostgreSQL, MySQL, and SQLite databases",
     )
+
+    # Global options for TUI mode
+    parser.add_argument(
+        "--mock",
+        metavar="PROFILE",
+        help="Run with mock data (profiles: sqlite-demo, empty, multi-db)",
+    )
+
     subparsers = parser.add_subparsers(dest="command", help="Available commands")
 
     # Connection commands
@@ -118,7 +126,17 @@ def main() -> int:
     if args.command is None:
         from .app import SSMSTUI
 
-        app = SSMSTUI()
+        mock_profile = None
+        if args.mock:
+            from .mocks import get_mock_profile, list_mock_profiles
+
+            mock_profile = get_mock_profile(args.mock)
+            if mock_profile is None:
+                print(f"Unknown mock profile: {args.mock}")
+                print(f"Available profiles: {', '.join(list_mock_profiles())}")
+                return 1
+
+        app = SSMSTUI(mock_profile=mock_profile)
         app.run()
         return 0
 

sqlit/app.py

@@ -16,6 +16,7 @@
     load_connections,
     save_connections,
 )
+from .db.schema import get_default_port, has_advanced_auth, is_file_based
 from .services import ConnectionSession, QueryResult, QueryService
 
 if TYPE_CHECKING:
@@ -33,19 +34,18 @@ def cmd_connection_list(args) -> int:
     print("-" * 95)
     for conn in connections:
         db_type_label = DATABASE_TYPE_LABELS.get(conn.get_db_type(), conn.db_type)
-        # File-based databases (SQLite, DuckDB)
-        if conn.db_type in ("sqlite", "duckdb"):
+        if is_file_based(conn.db_type):
             conn_info = conn.file_path[:38] + ".." if len(conn.file_path) > 40 else conn.file_path
             auth_label = "N/A"
-        # Server-based databases with simple auth
-        elif conn.db_type in ("postgresql", "mysql", "mariadb", "oracle", "cockroachdb"):
+        elif has_advanced_auth(conn.db_type):
             conn_info = f"{conn.server}@{conn.database}" if conn.database else conn.server
             conn_info = conn_info[:38] + ".." if len(conn_info) > 40 else conn_info
-            auth_label = f"User: {conn.username}" if conn.username else "N/A"
-        else:  # mssql (SQL Server)
+            auth_label = AUTH_TYPE_LABELS.get(conn.get_auth_type(), conn.auth_type)
+        else:
+            # Server-based databases with simple auth
             conn_info = f"{conn.server}@{conn.database}" if conn.database else conn.server
             conn_info = conn_info[:38] + ".." if len(conn_info) > 40 else conn_info
-            auth_label = AUTH_TYPE_LABELS.get(conn.get_auth_type(), conn.auth_type)
+            auth_label = f"User: {conn.username}" if conn.username else "N/A"
         print(
             f"{conn.name:<20} {db_type_label:<10} {conn_info:<40} {auth_label:<25}"
         )
@@ -69,8 +69,7 @@ def cmd_connection_create(args) -> int:
         print(f"Error: Invalid database type '{db_type}'. Valid types: {valid_types}")
         return 1
 
-    # File-based databases (SQLite, DuckDB)
-    if db_type in ("sqlite", "duckdb"):
+    if is_file_based(db_type):
         file_path = getattr(args, "file_path", None)
         if not file_path:
             print(f"Error: --file-path is required for {db_type.upper()} connections.")
@@ -81,28 +80,30 @@ def cmd_connection_create(args) -> int:
             db_type=db_type,
             file_path=file_path,
         )
-    # Server-based databases with simple auth (PostgreSQL, MySQL, MariaDB, Oracle, CockroachDB)
-    elif db_type in ("postgresql", "mysql", "mariadb", "oracle", "cockroachdb"):
+    elif has_advanced_auth(db_type):
+        # SQL Server connection (has Windows/Azure AD auth)
         if not args.server:
-            db_label = DATABASE_TYPE_LABELS.get(DatabaseType(db_type), db_type.upper())
-            print(f"Error: --server is required for {db_label} connections.")
+            print("Error: --server is required for SQL Server connections.")
+            return 1
+
+        auth_type_str = getattr(args, "auth_type", "sql") or "sql"
+        try:
+            auth_type = AuthType(auth_type_str)
+        except ValueError:
+            valid_types = ", ".join(t.value for t in AuthType)
+            print(f"Error: Invalid auth type '{auth_type_str}'. Valid types: {valid_types}")
             return 1
 
-        default_ports = {
-            "postgresql": "5432",
-            "mysql": "3306",
-            "mariadb": "3306",
-            "oracle": "1521",
-            "cockroachdb": "26257",
-        }
         config = ConnectionConfig(
             name=args.name,
             db_type=db_type,
             server=args.server,
-            port=args.port or default_ports.get(db_type, "1433"),
+            port=args.port or get_default_port(db_type),
             database=args.database or "",
             username=args.username or "",
             password=args.password or "",
+            auth_type=auth_type.value,
+            trusted_connection=(auth_type == AuthType.WINDOWS),
             ssh_enabled=getattr(args, "ssh_enabled", False) or False,
             ssh_host=getattr(args, "ssh_host", "") or "",
             ssh_port=getattr(args, "ssh_port", "22") or "22",
@@ -112,29 +113,20 @@ def cmd_connection_create(args) -> int:
             ssh_password=getattr(args, "ssh_password", "") or "",
         )
     else:
-        # SQL Server connection (mssql)
+        # Server-based databases with simple auth
         if not args.server:
-            print("Error: --server is required for SQL Server connections.")
-            return 1
-
-        auth_type_str = getattr(args, "auth_type", "sql") or "sql"
-        try:
-            auth_type = AuthType(auth_type_str)
-        except ValueError:
-            valid_types = ", ".join(t.value for t in AuthType)
-            print(f"Error: Invalid auth type '{auth_type_str}'. Valid types: {valid_types}")
+            db_label = DATABASE_TYPE_LABELS.get(DatabaseType(db_type), db_type.upper())
+            print(f"Error: --server is required for {db_label} connections.")
             return 1
 
         config = ConnectionConfig(
             name=args.name,
             db_type=db_type,
             server=args.server,
-            port=args.port or "1433",
+            port=args.port or get_default_port(db_type),
             database=args.database or "",
             username=args.username or "",
             password=args.password or "",
-            auth_type=auth_type.value,
-            trusted_connection=(auth_type == AuthType.WINDOWS),
             ssh_enabled=getattr(args, "ssh_enabled", False) or False,
             ssh_host=getattr(args, "ssh_host", "") or "",
             ssh_port=getattr(args, "ssh_port", "22") or "22",

sqlit/cli.py

@@ -28,6 +28,13 @@
 from .stores.settings import load_settings, save_settings
 
 
+# Import schema capabilities - use function to avoid circular imports
+def _is_file_based(db_type: str) -> bool:
+    from .db.schema import is_file_based
+
+    return is_file_based(db_type)
+
+
 class DatabaseType(Enum):
     """Supported database types."""
 
@@ -184,7 +191,7 @@ def get_connection_string(self) -> str:
 
     def get_display_info(self) -> str:
         """Get a display string for the connection."""
-        if self.db_type in ("sqlite", "duckdb"):
+        if _is_file_based(self.db_type):
             return self.file_path or self.name
 
         if self.db_type == "supabase":

sqlit/commands.py

@@ -20,7 +20,12 @@
     SelectOption,
     get_all_schemas,
     get_connection_schema,
+    get_default_port,
+    get_display_name,
     get_supported_db_types,
+    has_advanced_auth,
+    is_file_based,
+    supports_ssh,
 )
 from .tunnel import create_ssh_tunnel
 
@@ -46,7 +51,12 @@
     "SelectOption",
     "get_all_schemas",
     "get_connection_schema",
+    "get_default_port",
+    "get_display_name",
     "get_supported_db_types",
+    "has_advanced_auth",
+    "is_file_based",
+    "supports_ssh",
     # Tunnel
     "create_ssh_tunnel",
 ]